#ifdef __cplusplus
#define __STDC_FORMAT_MACROS
#endif
#include <inttypes.h>
#include <stdio.h>
#include <arm_neon.h>

// FIXME: this file misses tests for a small number of Neon intrinsics. Add
// the tests for these once emperor (ARM-internal test suite) has been improved
// to cover all Neon intrinsics as defined in the ACLE specification.

#define TEST_SATURATION 1
#define test_saturation(x) (TEST_SATURATION && (x))
static inline uint64_t get_fpsr()
{
  uint64_t fpsr;
  __asm__ __volatile__ ("mrs %0, FPSR"
                        : "=r"(fpsr)
                        :
                        : "memory"
                       );
  return fpsr;
}
static inline void set_fpsr(uint64_t mask, uint64_t value)
{
  uint64_t fpsr=get_fpsr();
  fpsr = (fpsr & ~mask) | (value & mask);
  __asm__ __volatile__ ("msr FPSR, %0"
                        :
                        : "r"(fpsr)
                        : "memory"
                       );
}

// Do not inline these functions, to make sure that they don't get reordered
// over the instructions that could set the saturation flag.
static __attribute__ ((noinline))
int get_neon_saturated(void)
{
    return get_fpsr() & (1<<27) ? 1 : 0;
}
static __attribute__ ((noinline))
int get_neon_saturated_inv(void)
{
    return !get_neon_saturated();
}
static __attribute__ ((noinline))
void clear_neon_saturated(void)
{
    set_fpsr(1<<27, 0);
}
static __attribute__ ((noinline))
void set_neon_saturated(void)
{
    set_fpsr(1<<27, 1<<27);
}

static int failed=0;

void dotests_1() {

{
   {
      int8x8_t arg1;
      int8x8_t arg2;
      int8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"add\", fnname = \"vadd_s8\", rettype = \"int8x8_t\", argtypes = \"[int8x8_t,int8x8_t]\", vals = [VectorVal [IntegerVal (-1),IntegerVal 127,IntegerVal 0,IntegerVal (-128),IntegerVal (-63),IntegerVal 20,IntegerVal (-1),IntegerVal 0],VectorVal [IntegerVal 127,IntegerVal (-128),IntegerVal 127,IntegerVal (-1),IntegerVal (-128),IntegerVal (-104),IntegerVal (-128),IntegerVal 127]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s8(UINT64_C(0x00ff14c180007fff));
      arg2 = vcreate_s8(UINT64_C(0x7f809880ff7f807f));
      clear_neon_saturated();
      //  Expect: "result" = 7f7fac417f7fff7e
      result = vadd_s8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s8(result), 0);
      exp = UINT64_C(0x7f7fac417f7fff7e);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2() {

{
   {
      int16x4_t arg1;
      int16x4_t arg2;
      int16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"add\", fnname = \"vadd_s16\", rettype = \"int16x4_t\", argtypes = \"[int16x4_t,int16x4_t]\", vals = [VectorVal [IntegerVal 32767,IntegerVal 0,IntegerVal (-32768),IntegerVal (-20246)],VectorVal [IntegerVal (-32768),IntegerVal (-1),IntegerVal 32767,IntegerVal 32767]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s16(UINT64_C(0xb0ea800000007fff));
      arg2 = vcreate_s16(UINT64_C(0x7fff7fffffff8000));
      clear_neon_saturated();
      //  Expect: "result" = 30e9ffffffffffff
      result = vadd_s16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s16(result), 0);
      exp = UINT64_C(0x30e9ffffffffffff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_3() {

{
   {
      int32x2_t arg1;
      int32x2_t arg2;
      int32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"add\", fnname = \"vadd_s32\", rettype = \"int32x2_t\", argtypes = \"[int32x2_t,int32x2_t]\", vals = [VectorVal [IntegerVal 25829,IntegerVal (-2147483648)],VectorVal [IntegerVal (-2147450881),IntegerVal (-32768)]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s32(UINT64_C(0x80000000000064e5));
      arg2 = vcreate_s32(UINT64_C(0xffff800080007fff));
      clear_neon_saturated();
      //  Expect: "result" = 7fff80008000e4e4
      result = vadd_s32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s32(result), 0);
      exp = UINT64_C(0x7fff80008000e4e4);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_4() {

{
   {
      int64x1_t arg1;
      int64x1_t arg2;
      int64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"add\", fnname = \"vadd_s64\", rettype = \"int64x1_t\", argtypes = \"[int64x1_t,int64x1_t]\", vals = [VectorVal [IntegerVal 9223231295506972671],VectorVal [IntegerVal (-2290581505)]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s64(UINT64_C(0x7fff7fff19f57fff));
      arg2 = vcreate_s64(UINT64_C(0xffffffff77787fff));
      clear_neon_saturated();
      //  Expect: "result" = 7fff7ffe916dfffe
      result = vadd_s64(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s64(result), 0);
      exp = UINT64_C(0x7fff7ffe916dfffe);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_5() {

{
   {
      float32x2_t arg1;
      float32x2_t arg2;
      float32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"add\", fnname = \"vadd_f32\", rettype = \"float32x2_t\", argtypes = \"[float32x2_t,float32x2_t]\", vals = [VectorVal [FloatVal 0.6478096842765808,FloatVal 0.1690211296081543],VectorVal [FloatVal 0.7901993989944458,FloatVal 0.3300831913948059]], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_f32(UINT64_C(0x3e2d13e03f25d6db));
      arg2 = vcreate_f32(UINT64_C(0x3ea900aa3f4a4a82));
      clear_neon_saturated();
      //  Expect: "result" = 3eff8a9a3fb810ae
      result = vadd_f32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result, 0);
         exp = ((float32_t) 1.4380090236663818);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result, 1);
         exp = ((float32_t) 0.4991043210029602);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
   }
}
}
void dotests_6() {

{
   {
      uint8x8_t arg1;
      uint8x8_t arg2;
      uint8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"add\", fnname = \"vadd_u8\", rettype = \"uint8x8_t\", argtypes = \"[uint8x8_t,uint8x8_t]\", vals = [VectorVal [IntegerVal 143,IntegerVal 255,IntegerVal 127,IntegerVal 255,IntegerVal 128,IntegerVal 127,IntegerVal 128,IntegerVal 127],VectorVal [IntegerVal 128,IntegerVal 111,IntegerVal 128,IntegerVal 0,IntegerVal 128,IntegerVal 38,IntegerVal 0,IntegerVal 128]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u8(UINT64_C(0x7f807f80ff7fff8f));
      arg2 = vcreate_u8(UINT64_C(0x8000268000806f80));
      clear_neon_saturated();
      //  Expect: "result" = ff80a500ffff6e0f
      result = vadd_u8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u8(result), 0);
      exp = UINT64_C(0xff80a500ffff6e0f);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_7() {

{
   {
      uint16x4_t arg1;
      uint16x4_t arg2;
      uint16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"add\", fnname = \"vadd_u16\", rettype = \"uint16x4_t\", argtypes = \"[uint16x4_t,uint16x4_t]\", vals = [VectorVal [IntegerVal 35968,IntegerVal 32768,IntegerVal 32767,IntegerVal 19602],VectorVal [IntegerVal 0,IntegerVal 0,IntegerVal 65535,IntegerVal 0]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u16(UINT64_C(0x4c927fff80008c80));
      arg2 = vcreate_u16(UINT64_C(0x0000ffff00000000));
      clear_neon_saturated();
      //  Expect: "result" = 4c927ffe80008c80
      result = vadd_u16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u16(result), 0);
      exp = UINT64_C(0x4c927ffe80008c80);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_8() {

{
   {
      uint32x2_t arg1;
      uint32x2_t arg2;
      uint32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"add\", fnname = \"vadd_u32\", rettype = \"uint32x2_t\", argtypes = \"[uint32x2_t,uint32x2_t]\", vals = [VectorVal [IntegerVal 3826483200,IntegerVal 65535],VectorVal [IntegerVal 1909227519,IntegerVal 1682898943]], start_saturated = True}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u32(UINT64_C(0x0000ffffe4138000));
      arg2 = vcreate_u32(UINT64_C(0x644effff71cc7fff));
      set_neon_saturated();
      //  Expect: "result" = 644ffffe55dfffff
      result = vadd_u32(arg1, arg2);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u32(result), 0);
      exp = UINT64_C(0x644ffffe55dfffff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_9() {

{
   {
      uint64x1_t arg1;
      uint64x1_t arg2;
      uint64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"add\", fnname = \"vadd_u64\", rettype = \"uint64x1_t\", argtypes = \"[uint64x1_t,uint64x1_t]\", vals = [VectorVal [IntegerVal 9223231299366391987],VectorVal [IntegerVal 18446603339490766811]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u64(UINT64_C(0x7fff7fffffff90b3));
      arg2 = vcreate_u64(UINT64_C(0xffff8000c2e1afdb));
      clear_neon_saturated();
      //  Expect: "result" = 7fff0000c2e1408e
      result = vadd_u64(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(result, 0);
      exp = UINT64_C(0x7fff0000c2e1408e);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_10() {

{
   {
      int8x16_t arg1;
      int8x16_t arg2;
      int8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"add\", fnname = \"vaddq_s8\", rettype = \"int8x16_t\", argtypes = \"[int8x16_t,int8x16_t]\", vals = [VectorVal [IntegerVal (-1),IntegerVal (-128),IntegerVal 127,IntegerVal 63,IntegerVal 0,IntegerVal (-57),IntegerVal (-1),IntegerVal (-1),IntegerVal 127,IntegerVal 0,IntegerVal 127,IntegerVal (-1),IntegerVal 25,IntegerVal (-118),IntegerVal (-128),IntegerVal (-1)],VectorVal [IntegerVal (-128),IntegerVal (-1),IntegerVal (-1),IntegerVal 127,IntegerVal 0,IntegerVal (-69),IntegerVal 90,IntegerVal (-1),IntegerVal 127,IntegerVal (-1),IntegerVal 0,IntegerVal 35,IntegerVal (-128),IntegerVal (-1),IntegerVal (-128),IntegerVal (-101)]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s8(vcreate_s8(UINT64_C(0xffffc7003f7f80ff)),
                         vcreate_s8(UINT64_C(0xff808a19ff7f007f)));
      arg2 = vcombine_s8(vcreate_s8(UINT64_C(0xff5abb007fffff80)),
                         vcreate_s8(UINT64_C(0x9b80ff802300ff7f)));
      clear_neon_saturated();
      //  Expect: "result" = 9a008999227ffffefe598200be7e7f7f
      result = vaddq_s8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result), 0);
         exp = UINT64_C(0xfe598200be7e7f7f);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result), 1);
         exp = UINT64_C(0x9a008999227ffffe);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_11() {

{
   {
      int16x8_t arg1;
      int16x8_t arg2;
      int16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"add\", fnname = \"vaddq_s16\", rettype = \"int16x8_t\", argtypes = \"[int16x8_t,int16x8_t]\", vals = [VectorVal [IntegerVal 0,IntegerVal (-32768),IntegerVal (-1),IntegerVal 27071,IntegerVal (-1),IntegerVal 0,IntegerVal (-860),IntegerVal (-32768)],VectorVal [IntegerVal (-32768),IntegerVal (-1549),IntegerVal 32767,IntegerVal 0,IntegerVal (-32515),IntegerVal 32767,IntegerVal 0,IntegerVal (-1)]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s16(vcreate_s16(UINT64_C(0x69bfffff80000000)),
                          vcreate_s16(UINT64_C(0x8000fca40000ffff)));
      arg2 = vcombine_s16(vcreate_s16(UINT64_C(0x00007ffff9f38000)),
                          vcreate_s16(UINT64_C(0xffff00007fff80fd)));
      clear_neon_saturated();
      //  Expect: "result" = 7ffffca47fff80fc69bf7ffe79f38000
      result = vaddq_s16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 0);
         exp = UINT64_C(0x69bf7ffe79f38000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 1);
         exp = UINT64_C(0x7ffffca47fff80fc);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_12() {

{
   {
      int32x4_t arg1;
      int32x4_t arg2;
      int32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"add\", fnname = \"vaddq_s32\", rettype = \"int32x4_t\", argtypes = \"[int32x4_t,int32x4_t]\", vals = [VectorVal [IntegerVal (-35529),IntegerVal 2147450879,IntegerVal (-2147450880),IntegerVal (-2147483648)],VectorVal [IntegerVal (-1),IntegerVal (-2147447473),IntegerVal 0,IntegerVal 65535]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s32(vcreate_s32(UINT64_C(0x7fff7fffffff7537)),
                          vcreate_s32(UINT64_C(0x8000000080008000)));
      arg2 = vcombine_s32(vcreate_s32(UINT64_C(0x80008d4fffffffff)),
                          vcreate_s32(UINT64_C(0x0000ffff00000000)));
      clear_neon_saturated();
      //  Expect: "result" = 8000ffff8000800000000d4effff7536
      result = vaddq_s32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 0);
         exp = UINT64_C(0x00000d4effff7536);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 1);
         exp = UINT64_C(0x8000ffff80008000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_13() {

{
   {
      int64x2_t arg1;
      int64x2_t arg2;
      int64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"add\", fnname = \"vaddq_s64\", rettype = \"int64x2_t\", argtypes = \"[int64x2_t,int64x2_t]\", vals = [VectorVal [IntegerVal (-65536),IntegerVal 4801400150582890932],VectorVal [IntegerVal 9223202200963022847,IntegerVal 281474976671794]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s64(vcreate_s64(UINT64_C(0xffffffffffff0000)),
                          vcreate_s64(UINT64_C(0x42a1ffff800011b4)));
      arg2 = vcombine_s64(vcreate_s64(UINT64_C(0x7fff658900007fff)),
                          vcreate_s64(UINT64_C(0x0000ffffffff6832)));
      clear_neon_saturated();
      //  Expect: "result" = 42a2ffff7fff79e67fff6588ffff7fff
      result = vaddq_s64(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 0);
         exp = UINT64_C(0x7fff6588ffff7fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 1);
         exp = UINT64_C(0x42a2ffff7fff79e6);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_14() {

{
   {
      float32x4_t arg1;
      float32x4_t arg2;
      float32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"add\", fnname = \"vaddq_f32\", rettype = \"float32x4_t\", argtypes = \"[float32x4_t,float32x4_t]\", vals = [VectorVal [FloatVal 0.9937112331390381,FloatVal 0.870923638343811,FloatVal 0.48253411054611206,FloatVal 0.8242339491844177],VectorVal [FloatVal 0.721931517124176,FloatVal 0.6431887149810791,FloatVal 0.5044335126876831,FloatVal 0.3438141345977783]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_f32(vcreate_f32(UINT64_C(0x3f5ef4da3f7e63dc)),
                          vcreate_f32(UINT64_C(0x3f5300ff3ef70eb6)));
      arg2 = vcombine_f32(vcreate_f32(UINT64_C(0x3f24a8043f38d081)),
                          vcreate_f32(UINT64_C(0x3eb008683f01228e)));
      clear_neon_saturated();
      //  Expect: "result" = 3f95829a3f7ca9e93fc1ce6f3fdb9a2e
      result = vaddq_f32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 0);
         exp = ((float32_t) 1.7156426906585693);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 1);
         exp = ((float32_t) 1.5141123533248901);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 2);
         exp = ((float32_t) 0.9869676232337952);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 2 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 3);
         exp = ((float32_t) 1.1680481433868408);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 3 ", exp, got);
            }
      }
   }
}
}
void dotests_15() {

{
   {
      uint8x16_t arg1;
      uint8x16_t arg2;
      uint8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"add\", fnname = \"vaddq_u8\", rettype = \"uint8x16_t\", argtypes = \"[uint8x16_t,uint8x16_t]\", vals = [VectorVal [IntegerVal 127,IntegerVal 255,IntegerVal 127,IntegerVal 0,IntegerVal 247,IntegerVal 127,IntegerVal 128,IntegerVal 128,IntegerVal 240,IntegerVal 255,IntegerVal 128,IntegerVal 127,IntegerVal 0,IntegerVal 255,IntegerVal 128,IntegerVal 0],VectorVal [IntegerVal 255,IntegerVal 170,IntegerVal 0,IntegerVal 127,IntegerVal 127,IntegerVal 255,IntegerVal 0,IntegerVal 127,IntegerVal 107,IntegerVal 128,IntegerVal 255,IntegerVal 127,IntegerVal 127,IntegerVal 67,IntegerVal 0,IntegerVal 127]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u8(vcreate_u8(UINT64_C(0x80807ff7007fff7f)),
                         vcreate_u8(UINT64_C(0x0080ff007f80fff0)));
      arg2 = vcombine_u8(vcreate_u8(UINT64_C(0x7f00ff7f7f00aaff)),
                         vcreate_u8(UINT64_C(0x7f00437f7fff806b)));
      clear_neon_saturated();
      //  Expect: "result" = 7f80427ffe7f7f5bff807e767f7fa97e
      result = vaddq_u8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 0);
         exp = UINT64_C(0xff807e767f7fa97e);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 1);
         exp = UINT64_C(0x7f80427ffe7f7f5b);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_16() {

{
   {
      uint16x8_t arg1;
      uint16x8_t arg2;
      uint16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"add\", fnname = \"vaddq_u16\", rettype = \"uint16x8_t\", argtypes = \"[uint16x8_t,uint16x8_t]\", vals = [VectorVal [IntegerVal 32767,IntegerVal 32767,IntegerVal 32767,IntegerVal 27789,IntegerVal 50382,IntegerVal 32767,IntegerVal 32767,IntegerVal 32768],VectorVal [IntegerVal 24385,IntegerVal 65535,IntegerVal 65535,IntegerVal 65535,IntegerVal 32767,IntegerVal 32767,IntegerVal 0,IntegerVal 51488]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u16(vcreate_u16(UINT64_C(0x6c8d7fff7fff7fff)),
                          vcreate_u16(UINT64_C(0x80007fff7fffc4ce)));
      arg2 = vcombine_u16(vcreate_u16(UINT64_C(0xffffffffffff5f41)),
                          vcreate_u16(UINT64_C(0xc92000007fff7fff)));
      clear_neon_saturated();
      //  Expect: "result" = 49207ffffffe44cd6c8c7ffe7ffedf40
      result = vaddq_u16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 0);
         exp = UINT64_C(0x6c8c7ffe7ffedf40);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 1);
         exp = UINT64_C(0x49207ffffffe44cd);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_17() {

{
   {
      uint32x4_t arg1;
      uint32x4_t arg2;
      uint32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"add\", fnname = \"vaddq_u32\", rettype = \"uint32x4_t\", argtypes = \"[uint32x4_t,uint32x4_t]\", vals = [VectorVal [IntegerVal 2147450879,IntegerVal 20857,IntegerVal 2147450880,IntegerVal 2147447855],VectorVal [IntegerVal 1888223231,IntegerVal 135757823,IntegerVal 32767,IntegerVal 526876672]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u32(vcreate_u32(UINT64_C(0x000051797fff7fff)),
                          vcreate_u32(UINT64_C(0x7fff742f7fff8000)));
      arg2 = vcombine_u32(vcreate_u32(UINT64_C(0x08177fff708bffff)),
                          vcreate_u32(UINT64_C(0x1f67800000007fff)));
      clear_neon_saturated();
      //  Expect: "result" = 9f66f42f7fffffff0817d178f08b7ffe
      result = vaddq_u32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 0);
         exp = UINT64_C(0x0817d178f08b7ffe);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 1);
         exp = UINT64_C(0x9f66f42f7fffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_18() {

{
   {
      uint64x2_t arg1;
      uint64x2_t arg2;
      uint64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"add\", fnname = \"vaddq_u64\", rettype = \"uint64x2_t\", argtypes = \"[uint64x2_t,uint64x2_t]\", vals = [VectorVal [IntegerVal 13972959722760896511,IntegerVal 9223576122963230719],VectorVal [IntegerVal 12497911181332119552,IntegerVal 9223231303661387775]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u64(vcreate_u64(UINT64_C(0xc1e9ecd60000ffff)),
                          vcreate_u64(UINT64_C(0x8000b99d7fff7fff)));
      arg2 = vcombine_u64(vcreate_u64(UINT64_C(0xad718000adaf0000)),
                          vcreate_u64(UINT64_C(0x7fff8000ffffffff)));
      clear_neon_saturated();
      //  Expect: "result" = 0000399e7fff7ffe6f5b6cd6adafffff
      result = vaddq_u64(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 0);
         exp = UINT64_C(0x6f5b6cd6adafffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 1);
         exp = UINT64_C(0x0000399e7fff7ffe);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_19() {

{
   {
      float64x1_t arg1;
      float64x1_t arg2;
      float64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"add\", fnname = \"vadd_f64\", rettype = \"float64x1_t\", argtypes = \"[float64x1_t,float64x1_t]\", vals = [VectorVal [FloatVal 0.7272158868577863],VectorVal [FloatVal 0.7995861011279443]], start_saturated = True}";
      int reported = 0;
      float64_t got;
      float64_t exp;
      arg1 = vcreate_f64(UINT64_C(0x3fe7455a4065f24e));
      arg2 = vcreate_f64(UINT64_C(0x3fe996359755c80b));
      set_neon_saturated();
      //  Expect: "result" = 3ff86dc7ebdddd2c
      result = vadd_f64(arg1, arg2);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      got = vget_lane_f64(result, 0);
      exp = 1.5268019879857304;
      if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
         }
   }
}
}
void dotests_20() {

{
   {
      float64x2_t arg1;
      float64x2_t arg2;
      float64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"add\", fnname = \"vaddq_f64\", rettype = \"float64x2_t\", argtypes = \"[float64x2_t,float64x2_t]\", vals = [VectorVal [FloatVal 0.625577838098139,FloatVal 0.37438043683304323],VectorVal [FloatVal 0.2792863290849389,FloatVal 0.42160559330924874]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_f64(vcreate_f64(UINT64_C(0x3fe404bbd0777c07)),
                          vcreate_f64(UINT64_C(0x3fd7f5d95d1d7284)));
      arg2 = vcombine_f64(vcreate_f64(UINT64_C(0x3fd1dfd3c468f0f2)),
                          vcreate_f64(UINT64_C(0x3fdafb9606c4bac6)));
      clear_neon_saturated();
      //  Expect: "result" = 3fe978b7b1f116a53fecf4a5b2abf480
      result = vaddq_f64(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float64_t got;
         float64_t exp;
         got = vgetq_lane_f64(result, 0);
         exp = 0.9048641671830779;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float64_t got;
         float64_t exp;
         got = vgetq_lane_f64(result, 1);
         exp = 0.795986030142292;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
   }
}
}
void dotests_21() {

{
   {
      int64_t arg1;
      int64_t arg2;
      int64_t result;
      char* str1 = "ReproInfo2 {semantics = \"add\", fnname = \"vaddd_s64\", rettype = \"int64_t\", argtypes = \"[int64_t,int64_t]\", vals = [IntegerVal 1752040990387929088,IntegerVal 140739635904511], start_saturated = False}";
      int reported = 0;
      int64_t got;
      int64_t exp;
      arg1 = INT64_C(1752040990387929088);
      arg2 = INT64_C(140739635904511);
      clear_neon_saturated();
      //  Expect: "result" = 1850ffffffffffff
      result = vaddd_s64(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = INT64_C(1752181730023833599);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIi64 " Got: %" PRIi64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_22() {

{
   {
      uint64_t arg1;
      uint64_t arg2;
      uint64_t result;
      char* str1 = "ReproInfo2 {semantics = \"add\", fnname = \"vaddd_u64\", rettype = \"uint64_t\", argtypes = \"[uint64_t,uint64_t]\", vals = [IntegerVal 9223653509683937280,IntegerVal 9223372039002324991], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = UINT64_C(0x8000ffff7fff0000);
      arg2 = UINT64_C(0x800000008000ffff);
      clear_neon_saturated();
      //  Expect: "result" = 0000ffffffffffff
      result = vaddd_u64(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = UINT64_C(0x0000ffffffffffff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_23() {

{
   {
      int8x8_t arg1;
      int8x8_t arg2;
      int16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"add\", fnname = \"vaddl_s8\", rettype = \"int16x8_t\", argtypes = \"[int8x8_t,int8x8_t]\", vals = [VectorVal [IntegerVal (-1),IntegerVal (-1),IntegerVal (-128),IntegerVal (-128),IntegerVal (-1),IntegerVal (-1),IntegerVal (-117),IntegerVal (-107)],VectorVal [IntegerVal (-1),IntegerVal (-1),IntegerVal (-128),IntegerVal 0,IntegerVal (-1),IntegerVal (-110),IntegerVal 127,IntegerVal 0]], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_s8(UINT64_C(0x958bffff8080ffff));
      arg2 = vcreate_s8(UINT64_C(0x007f92ff0080ffff));
      clear_neon_saturated();
      //  Expect: "result" = ff95000aff91fffeff80ff00fffefffe
      result = vaddl_s8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 0);
         exp = UINT64_C(0xff80ff00fffefffe);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 1);
         exp = UINT64_C(0xff95000aff91fffe);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_24() {

{
   {
      int16x4_t arg1;
      int16x4_t arg2;
      int32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"add\", fnname = \"vaddl_s16\", rettype = \"int32x4_t\", argtypes = \"[int16x4_t,int16x4_t]\", vals = [VectorVal [IntegerVal 32767,IntegerVal (-32768),IntegerVal 0,IntegerVal (-11684)],VectorVal [IntegerVal 0,IntegerVal (-1625),IntegerVal (-1),IntegerVal (-32768)]], start_saturated = True}";
      int reported = 0;
      arg1 = vcreate_s16(UINT64_C(0xd25c000080007fff));
      arg2 = vcreate_s16(UINT64_C(0x8000fffff9a70000));
      set_neon_saturated();
      //  Expect: "result" = ffff525cffffffffffff79a700007fff
      result = vaddl_s16(arg1, arg2);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 0);
         exp = UINT64_C(0xffff79a700007fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 1);
         exp = UINT64_C(0xffff525cffffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_25() {

{
   {
      int32x2_t arg1;
      int32x2_t arg2;
      int64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"add\", fnname = \"vaddl_s32\", rettype = \"int64x2_t\", argtypes = \"[int32x2_t,int32x2_t]\", vals = [VectorVal [IntegerVal (-32768),IntegerVal (-2147483648)],VectorVal [IntegerVal 62231,IntegerVal (-2147482517)]], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_s32(UINT64_C(0x80000000ffff8000));
      arg2 = vcreate_s32(UINT64_C(0x8000046b0000f317));
      clear_neon_saturated();
      //  Expect: "result" = ffffffff0000046b0000000000007317
      result = vaddl_s32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 0);
         exp = UINT64_C(0x0000000000007317);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 1);
         exp = UINT64_C(0xffffffff0000046b);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_26() {

{
   {
      uint8x8_t arg1;
      uint8x8_t arg2;
      uint16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"add\", fnname = \"vaddl_u8\", rettype = \"uint16x8_t\", argtypes = \"[uint8x8_t,uint8x8_t]\", vals = [VectorVal [IntegerVal 128,IntegerVal 128,IntegerVal 0,IntegerVal 128,IntegerVal 247,IntegerVal 127,IntegerVal 255,IntegerVal 128],VectorVal [IntegerVal 0,IntegerVal 127,IntegerVal 128,IntegerVal 0,IntegerVal 0,IntegerVal 128,IntegerVal 226,IntegerVal 16]], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_u8(UINT64_C(0x80ff7ff780008080));
      arg2 = vcreate_u8(UINT64_C(0x10e2800000807f00));
      clear_neon_saturated();
      //  Expect: "result" = 009001e100ff00f70080008000ff0080
      result = vaddl_u8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 0);
         exp = UINT64_C(0x0080008000ff0080);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 1);
         exp = UINT64_C(0x009001e100ff00f7);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_27() {

{
   {
      uint16x4_t arg1;
      uint16x4_t arg2;
      uint32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"add\", fnname = \"vaddl_u16\", rettype = \"uint32x4_t\", argtypes = \"[uint16x4_t,uint16x4_t]\", vals = [VectorVal [IntegerVal 32767,IntegerVal 32768,IntegerVal 0,IntegerVal 0],VectorVal [IntegerVal 65535,IntegerVal 32768,IntegerVal 32768,IntegerVal 32768]], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_u16(UINT64_C(0x0000000080007fff));
      arg2 = vcreate_u16(UINT64_C(0x800080008000ffff));
      clear_neon_saturated();
      //  Expect: "result" = 00008000000080000001000000017ffe
      result = vaddl_u16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 0);
         exp = UINT64_C(0x0001000000017ffe);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 1);
         exp = UINT64_C(0x0000800000008000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_28() {

{
   {
      uint32x2_t arg1;
      uint32x2_t arg2;
      uint64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"add\", fnname = \"vaddl_u32\", rettype = \"uint64x2_t\", argtypes = \"[uint32x2_t,uint32x2_t]\", vals = [VectorVal [IntegerVal 2147483647,IntegerVal 2147450879],VectorVal [IntegerVal 4294967295,IntegerVal 56194]], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_u32(UINT64_C(0x7fff7fff7fffffff));
      arg2 = vcreate_u32(UINT64_C(0x0000db82ffffffff));
      clear_neon_saturated();
      //  Expect: "result" = 0000000080005b81000000017ffffffe
      result = vaddl_u32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 0);
         exp = UINT64_C(0x000000017ffffffe);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 1);
         exp = UINT64_C(0x0000000080005b81);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_29() {

{
   {
      int8x16_t arg1;
      int8x16_t arg2;
      int16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"add\", fnname = \"vaddl_high_s8\", rettype = \"int16x8_t\", argtypes = \"[int8x16_t,int8x16_t]\", vals = [VectorVal [IntegerVal 127,IntegerVal (-128),IntegerVal (-65),IntegerVal 127,IntegerVal 127,IntegerVal (-128),IntegerVal 0,IntegerVal (-128),IntegerVal 127,IntegerVal (-24),IntegerVal 127,IntegerVal (-1),IntegerVal (-128),IntegerVal 73,IntegerVal (-1),IntegerVal 127],VectorVal [IntegerVal (-1),IntegerVal (-128),IntegerVal (-1),IntegerVal (-1),IntegerVal 127,IntegerVal 79,IntegerVal 127,IntegerVal (-89),IntegerVal 0,IntegerVal 127,IntegerVal (-128),IntegerVal (-64),IntegerVal 0,IntegerVal (-128),IntegerVal 127,IntegerVal (-1)]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s8(vcreate_s8(UINT64_C(0x8000807f7fbf807f)),
                         vcreate_s8(UINT64_C(0x7fff4980ff7fe87f)));
      arg2 = vcombine_s8(vcreate_s8(UINT64_C(0xa77f4f7fffff80ff)),
                         vcreate_s8(UINT64_C(0xff7f8000c0807f00)));
      clear_neon_saturated();
      //  Expect: "result" = 007e007effc9ff80ffbfffff0067007f
      result = vaddl_high_s8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 0);
         exp = UINT64_C(0xffbfffff0067007f);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 1);
         exp = UINT64_C(0x007e007effc9ff80);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_30() {

{
   {
      int16x8_t arg1;
      int16x8_t arg2;
      int32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"add\", fnname = \"vaddl_high_s16\", rettype = \"int32x4_t\", argtypes = \"[int16x8_t,int16x8_t]\", vals = [VectorVal [IntegerVal 32767,IntegerVal 0,IntegerVal 1884,IntegerVal (-1),IntegerVal (-32768),IntegerVal (-32768),IntegerVal (-1),IntegerVal (-32768)],VectorVal [IntegerVal (-1),IntegerVal (-32768),IntegerVal (-1),IntegerVal 32767,IntegerVal (-32768),IntegerVal 32767,IntegerVal 0,IntegerVal (-32768)]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s16(vcreate_s16(UINT64_C(0xffff075c00007fff)),
                          vcreate_s16(UINT64_C(0x8000ffff80008000)));
      arg2 = vcombine_s16(vcreate_s16(UINT64_C(0x7fffffff8000ffff)),
                          vcreate_s16(UINT64_C(0x800000007fff8000)));
      clear_neon_saturated();
      //  Expect: "result" = ffff0000ffffffffffffffffffff0000
      result = vaddl_high_s16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 0);
         exp = UINT64_C(0xffffffffffff0000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 1);
         exp = UINT64_C(0xffff0000ffffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_31() {

{
   {
      int32x4_t arg1;
      int32x4_t arg2;
      int64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"add\", fnname = \"vaddl_high_s32\", rettype = \"int64x2_t\", argtypes = \"[int32x4_t,int32x4_t]\", vals = [VectorVal [IntegerVal (-32768),IntegerVal 1306951680,IntegerVal 2147466781,IntegerVal (-32768)],VectorVal [IntegerVal (-2147450880),IntegerVal (-2147418113),IntegerVal 2147449047,IntegerVal (-2147483648)]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s32(vcreate_s32(UINT64_C(0x4de68000ffff8000)),
                          vcreate_s32(UINT64_C(0xffff80007fffbe1d)));
      arg2 = vcombine_s32(vcreate_s32(UINT64_C(0x8000ffff80008000)),
                          vcreate_s32(UINT64_C(0x800000007fff78d7)));
      clear_neon_saturated();
      //  Expect: "result" = ffffffff7fff800000000000ffff36f4
      result = vaddl_high_s32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 0);
         exp = UINT64_C(0x00000000ffff36f4);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 1);
         exp = UINT64_C(0xffffffff7fff8000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_32() {

{
   {
      uint8x16_t arg1;
      uint8x16_t arg2;
      uint16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"add\", fnname = \"vaddl_high_u8\", rettype = \"uint16x8_t\", argtypes = \"[uint8x16_t,uint8x16_t]\", vals = [VectorVal [IntegerVal 246,IntegerVal 128,IntegerVal 213,IntegerVal 127,IntegerVal 255,IntegerVal 128,IntegerVal 0,IntegerVal 0,IntegerVal 11,IntegerVal 127,IntegerVal 233,IntegerVal 92,IntegerVal 127,IntegerVal 127,IntegerVal 128,IntegerVal 255],VectorVal [IntegerVal 255,IntegerVal 0,IntegerVal 128,IntegerVal 128,IntegerVal 128,IntegerVal 128,IntegerVal 255,IntegerVal 162,IntegerVal 128,IntegerVal 255,IntegerVal 128,IntegerVal 127,IntegerVal 127,IntegerVal 127,IntegerVal 127,IntegerVal 128]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u8(vcreate_u8(UINT64_C(0x000080ff7fd580f6)),
                         vcreate_u8(UINT64_C(0xff807f7f5ce97f0b)));
      arg2 = vcombine_u8(vcreate_u8(UINT64_C(0xa2ff8080808000ff)),
                         vcreate_u8(UINT64_C(0x807f7f7f7f80ff80)));
      clear_neon_saturated();
      //  Expect: "result" = 017f00ff00fe00fe00db0169017e008b
      result = vaddl_high_u8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 0);
         exp = UINT64_C(0x00db0169017e008b);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 1);
         exp = UINT64_C(0x017f00ff00fe00fe);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_33() {

{
   {
      uint16x8_t arg1;
      uint16x8_t arg2;
      uint32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"add\", fnname = \"vaddl_high_u16\", rettype = \"uint32x4_t\", argtypes = \"[uint16x8_t,uint16x8_t]\", vals = [VectorVal [IntegerVal 65535,IntegerVal 65535,IntegerVal 36107,IntegerVal 56373,IntegerVal 0,IntegerVal 32768,IntegerVal 65535,IntegerVal 32767],VectorVal [IntegerVal 32768,IntegerVal 32767,IntegerVal 32768,IntegerVal 32767,IntegerVal 0,IntegerVal 10016,IntegerVal 65535,IntegerVal 32767]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u16(vcreate_u16(UINT64_C(0xdc358d0bffffffff)),
                          vcreate_u16(UINT64_C(0x7fffffff80000000)));
      arg2 = vcombine_u16(vcreate_u16(UINT64_C(0x7fff80007fff8000)),
                          vcreate_u16(UINT64_C(0x7fffffff27200000)));
      clear_neon_saturated();
      //  Expect: "result" = 0000fffe0001fffe0000a72000000000
      result = vaddl_high_u16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 0);
         exp = UINT64_C(0x0000a72000000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 1);
         exp = UINT64_C(0x0000fffe0001fffe);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_34() {

{
   {
      uint32x4_t arg1;
      uint32x4_t arg2;
      uint64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"add\", fnname = \"vaddl_high_u32\", rettype = \"uint64x2_t\", argtypes = \"[uint32x4_t,uint32x4_t]\", vals = [VectorVal [IntegerVal 4294934527,IntegerVal 2278490112,IntegerVal 2147450880,IntegerVal 32767],VectorVal [IntegerVal 2147499193,IntegerVal 411238399,IntegerVal 65535,IntegerVal 32767]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u32(vcreate_u32(UINT64_C(0x87cf0000ffff7fff)),
                          vcreate_u32(UINT64_C(0x00007fff7fff8000)));
      arg2 = vcombine_u32(vcreate_u32(UINT64_C(0x1882ffff80003cb9)),
                          vcreate_u32(UINT64_C(0x00007fff0000ffff)));
      clear_neon_saturated();
      //  Expect: "result" = 000000000000fffe0000000080007fff
      result = vaddl_high_u32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 0);
         exp = UINT64_C(0x0000000080007fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 1);
         exp = UINT64_C(0x000000000000fffe);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_35() {

{
   {
      int16x8_t arg1;
      int8x8_t arg2;
      int16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"add\", fnname = \"vaddw_s8\", rettype = \"int16x8_t\", argtypes = \"[int16x8_t,int8x8_t]\", vals = [VectorVal [IntegerVal 32767,IntegerVal (-1),IntegerVal 0,IntegerVal (-1),IntegerVal (-32768),IntegerVal (-1),IntegerVal 0,IntegerVal (-1)],VectorVal [IntegerVal (-1),IntegerVal 93,IntegerVal (-128),IntegerVal 0,IntegerVal 0,IntegerVal (-116),IntegerVal (-1),IntegerVal 0]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s16(vcreate_s16(UINT64_C(0xffff0000ffff7fff)),
                          vcreate_s16(UINT64_C(0xffff0000ffff8000)));
      arg2 = vcreate_s8(UINT64_C(0x00ff8c0000805dff));
      clear_neon_saturated();
      //  Expect: "result" = ffffffffff8b8000ffffff80005c7ffe
      result = vaddw_s8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 0);
         exp = UINT64_C(0xffffff80005c7ffe);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 1);
         exp = UINT64_C(0xffffffffff8b8000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_36() {

{
   {
      int32x4_t arg1;
      int16x4_t arg2;
      int32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"add\", fnname = \"vaddw_s16\", rettype = \"int32x4_t\", argtypes = \"[int32x4_t,int16x4_t]\", vals = [VectorVal [IntegerVal 65535,IntegerVal 2147450879,IntegerVal (-2147450880),IntegerVal (-2147442040)],VectorVal [IntegerVal (-28058),IntegerVal (-32768),IntegerVal 0,IntegerVal (-1)]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s32(vcreate_s32(UINT64_C(0x7fff7fff0000ffff)),
                          vcreate_s32(UINT64_C(0x8000a28880008000)));
      arg2 = vcreate_s16(UINT64_C(0xffff000080009266));
      clear_neon_saturated();
      //  Expect: "result" = 8000a287800080007ffeffff00009265
      result = vaddw_s16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 0);
         exp = UINT64_C(0x7ffeffff00009265);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 1);
         exp = UINT64_C(0x8000a28780008000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_37() {

{
   {
      int64x2_t arg1;
      int32x2_t arg2;
      int64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"add\", fnname = \"vaddw_s32\", rettype = \"int64x2_t\", argtypes = \"[int64x2_t,int32x2_t]\", vals = [VectorVal [IntegerVal 281470681808895,IntegerVal 281474976645120],VectorVal [IntegerVal (-2147458980),IntegerVal (-65536)]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s64(vcreate_s64(UINT64_C(0x0000ffff0000ffff)),
                          vcreate_s64(UINT64_C(0x0000ffffffff0000)));
      arg2 = vcreate_s32(UINT64_C(0xffff00008000605c));
      clear_neon_saturated();
      //  Expect: "result" = 0000fffffffe00000000fffe8001605b
      result = vaddw_s32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 0);
         exp = UINT64_C(0x0000fffe8001605b);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 1);
         exp = UINT64_C(0x0000fffffffe0000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_38() {

{
   {
      uint16x8_t arg1;
      uint8x8_t arg2;
      uint16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"add\", fnname = \"vaddw_u8\", rettype = \"uint16x8_t\", argtypes = \"[uint16x8_t,uint8x8_t]\", vals = [VectorVal [IntegerVal 0,IntegerVal 29032,IntegerVal 8602,IntegerVal 32767,IntegerVal 32767,IntegerVal 0,IntegerVal 65535,IntegerVal 32767],VectorVal [IntegerVal 0,IntegerVal 0,IntegerVal 128,IntegerVal 255,IntegerVal 137,IntegerVal 255,IntegerVal 255,IntegerVal 0]], start_saturated = True}";
      int reported = 0;
      arg1 = vcombine_u16(vcreate_u16(UINT64_C(0x7fff219a71680000)),
                          vcreate_u16(UINT64_C(0x7fffffff00007fff)));
      arg2 = vcreate_u8(UINT64_C(0x00ffff89ff800000));
      set_neon_saturated();
      //  Expect: "result" = 7fff00fe00ff808880fe221a71680000
      result = vaddw_u8(arg1, arg2);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 0);
         exp = UINT64_C(0x80fe221a71680000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 1);
         exp = UINT64_C(0x7fff00fe00ff8088);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_39() {

{
   {
      uint32x4_t arg1;
      uint16x4_t arg2;
      uint32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"add\", fnname = \"vaddw_u16\", rettype = \"uint32x4_t\", argtypes = \"[uint32x4_t,uint16x4_t]\", vals = [VectorVal [IntegerVal 32768,IntegerVal 2147448269,IntegerVal 3882024959,IntegerVal 4294901760],VectorVal [IntegerVal 65535,IntegerVal 59438,IntegerVal 0,IntegerVal 65535]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u32(vcreate_u32(UINT64_C(0x7fff75cd00008000)),
                          vcreate_u32(UINT64_C(0xffff0000e762ffff)));
      arg2 = vcreate_u16(UINT64_C(0xffff0000e82effff));
      clear_neon_saturated();
      //  Expect: "result" = ffffffffe762ffff80005dfb00017fff
      result = vaddw_u16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 0);
         exp = UINT64_C(0x80005dfb00017fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 1);
         exp = UINT64_C(0xffffffffe762ffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_40() {

{
   {
      uint64x2_t arg1;
      uint32x2_t arg2;
      uint64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"add\", fnname = \"vaddw_u32\", rettype = \"uint64x2_t\", argtypes = \"[uint64x2_t,uint32x2_t]\", vals = [VectorVal [IntegerVal 9223372039002226687,IntegerVal 140741783266598],VectorVal [IntegerVal 2147450879,IntegerVal 2147516416]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u64(vcreate_u64(UINT64_C(0x800000007fff7fff)),
                          vcreate_u64(UINT64_C(0x00008000ffff2526)));
      arg2 = vcreate_u32(UINT64_C(0x800080007fff7fff));
      clear_neon_saturated();
      //  Expect: "result" = 000080017fffa52680000000fffefffe
      result = vaddw_u32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 0);
         exp = UINT64_C(0x80000000fffefffe);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 1);
         exp = UINT64_C(0x000080017fffa526);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_41() {

{
   {
      int16x8_t arg1;
      int8x16_t arg2;
      int16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"add\", fnname = \"vaddw_high_s8\", rettype = \"int16x8_t\", argtypes = \"[int16x8_t,int8x16_t]\", vals = [VectorVal [IntegerVal 32767,IntegerVal (-12481),IntegerVal (-1),IntegerVal 0,IntegerVal (-32768),IntegerVal 0,IntegerVal (-1),IntegerVal 2613],VectorVal [IntegerVal 127,IntegerVal (-87),IntegerVal (-1),IntegerVal 127,IntegerVal (-1),IntegerVal (-128),IntegerVal 0,IntegerVal (-42),IntegerVal 127,IntegerVal (-128),IntegerVal 127,IntegerVal (-26),IntegerVal 76,IntegerVal (-128),IntegerVal (-128),IntegerVal 0]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s16(vcreate_s16(UINT64_C(0x0000ffffcf3f7fff)),
                          vcreate_s16(UINT64_C(0x0a35ffff00008000)));
      arg2 = vcombine_s8(vcreate_s8(UINT64_C(0xd60080ff7fffa97f)),
                         vcreate_s8(UINT64_C(0x0080804ce67f807f)));
      clear_neon_saturated();
      //  Expect: "result" = 0a35ff7fff80804cffe6007ecebf807e
      result = vaddw_high_s8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 0);
         exp = UINT64_C(0xffe6007ecebf807e);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 1);
         exp = UINT64_C(0x0a35ff7fff80804c);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_42() {

{
   {
      int32x4_t arg1;
      int16x8_t arg2;
      int32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"add\", fnname = \"vaddw_high_s16\", rettype = \"int32x4_t\", argtypes = \"[int32x4_t,int16x8_t]\", vals = [VectorVal [IntegerVal 2147434387,IntegerVal (-1518108672),IntegerVal (-2147483648),IntegerVal (-2147418113)],VectorVal [IntegerVal 0,IntegerVal (-1),IntegerVal 32767,IntegerVal 32767,IntegerVal (-1),IntegerVal (-1),IntegerVal (-32768),IntegerVal (-27287)]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s32(vcreate_s32(UINT64_C(0xa58380007fff3f93)),
                          vcreate_s32(UINT64_C(0x8000ffff80000000)));
      arg2 = vcombine_s16(vcreate_s16(UINT64_C(0x7fff7fffffff0000)),
                          vcreate_s16(UINT64_C(0x95698000ffffffff)));
      clear_neon_saturated();
      //  Expect: "result" = 800095687fff8000a5837fff7fff3f92
      result = vaddw_high_s16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 0);
         exp = UINT64_C(0xa5837fff7fff3f92);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 1);
         exp = UINT64_C(0x800095687fff8000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_43() {

{
   {
      int64x2_t arg1;
      int32x4_t arg2;
      int64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"add\", fnname = \"vaddw_high_s32\", rettype = \"int64x2_t\", argtypes = \"[int64x2_t,int32x4_t]\", vals = [VectorVal [IntegerVal 281472829280455,IntegerVal (-9223231297218969600)],VectorVal [IntegerVal 2147483647,IntegerVal 1314914303,IntegerVal (-2147418113),IntegerVal 2147430857]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s64(vcreate_s64(UINT64_C(0x0000ffff8000d0c7)),
                          vcreate_s64(UINT64_C(0x800080007fff8000)));
      arg2 = vcombine_s32(vcreate_s32(UINT64_C(0x4e5fffff7fffffff)),
                          vcreate_s32(UINT64_C(0x7fff31c98000ffff)));
      clear_neon_saturated();
      //  Expect: "result" = 80008000fffeb1c90000ffff0001d0c6
      result = vaddw_high_s32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 0);
         exp = UINT64_C(0x0000ffff0001d0c6);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 1);
         exp = UINT64_C(0x80008000fffeb1c9);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_44() {

{
   {
      uint16x8_t arg1;
      uint8x16_t arg2;
      uint16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"add\", fnname = \"vaddw_high_u8\", rettype = \"uint16x8_t\", argtypes = \"[uint16x8_t,uint8x16_t]\", vals = [VectorVal [IntegerVal 65535,IntegerVal 32767,IntegerVal 32767,IntegerVal 42786,IntegerVal 65535,IntegerVal 32768,IntegerVal 7757,IntegerVal 47026],VectorVal [IntegerVal 128,IntegerVal 33,IntegerVal 255,IntegerVal 128,IntegerVal 255,IntegerVal 255,IntegerVal 0,IntegerVal 128,IntegerVal 255,IntegerVal 127,IntegerVal 255,IntegerVal 128,IntegerVal 7,IntegerVal 0,IntegerVal 127,IntegerVal 127]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u16(vcreate_u16(UINT64_C(0xa7227fff7fffffff)),
                          vcreate_u16(UINT64_C(0xb7b21e4d8000ffff)));
      arg2 = vcombine_u8(vcreate_u8(UINT64_C(0x8000ffff80ff2180)),
                         vcreate_u8(UINT64_C(0x7f7f000780ff7fff)));
      clear_neon_saturated();
      //  Expect: "result" = b8311ecc80000006a7a280fe807e00fe
      result = vaddw_high_u8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 0);
         exp = UINT64_C(0xa7a280fe807e00fe);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 1);
         exp = UINT64_C(0xb8311ecc80000006);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_45() {

{
   {
      uint32x4_t arg1;
      uint16x8_t arg2;
      uint32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"add\", fnname = \"vaddw_high_u16\", rettype = \"uint32x4_t\", argtypes = \"[uint32x4_t,uint16x8_t]\", vals = [VectorVal [IntegerVal 2147549183,IntegerVal 221807068,IntegerVal 2147535456,IntegerVal 2147516416],VectorVal [IntegerVal 50124,IntegerVal 32768,IntegerVal 0,IntegerVal 32767,IntegerVal 65535,IntegerVal 65535,IntegerVal 32768,IntegerVal 32768]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u32(vcreate_u32(UINT64_C(0x0d3881dc8000ffff)),
                          vcreate_u32(UINT64_C(0x800080008000ca60)));
      arg2 = vcombine_u16(vcreate_u16(UINT64_C(0x7fff00008000c3cc)),
                          vcreate_u16(UINT64_C(0x80008000ffffffff)));
      clear_neon_saturated();
      //  Expect: "result" = 8001000080014a600d3981db8001fffe
      result = vaddw_high_u16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 0);
         exp = UINT64_C(0x0d3981db8001fffe);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 1);
         exp = UINT64_C(0x8001000080014a60);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_46() {

{
   {
      uint64x2_t arg1;
      uint32x4_t arg2;
      uint64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"add\", fnname = \"vaddw_high_u32\", rettype = \"uint64x2_t\", argtypes = \"[uint64x2_t,uint32x4_t]\", vals = [VectorVal [IntegerVal 9223090564025548799,IntegerVal 18446462600880324608],VectorVal [IntegerVal 2085355520,IntegerVal 2147418112,IntegerVal 13926,IntegerVal 2147483647]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u64(vcreate_u64(UINT64_C(0x7fff00007fffffff)),
                          vcreate_u64(UINT64_C(0xffff000080000000)));
      arg2 = vcombine_u32(vcreate_u32(UINT64_C(0x7fff00007c4c0000)),
                          vcreate_u32(UINT64_C(0x7fffffff00003666)));
      clear_neon_saturated();
      //  Expect: "result" = ffff0000ffffffff7fff000080003665
      result = vaddw_high_u32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 0);
         exp = UINT64_C(0x7fff000080003665);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 1);
         exp = UINT64_C(0xffff0000ffffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_47() {

{
   {
      int8x8_t arg1;
      int8x8_t arg2;
      int8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"halving_add\", fnname = \"vhadd_s8\", rettype = \"int8x8_t\", argtypes = \"[int8x8_t,int8x8_t]\", vals = [VectorVal [IntegerVal (-1),IntegerVal 0,IntegerVal (-128),IntegerVal (-128),IntegerVal (-1),IntegerVal 127,IntegerVal (-128),IntegerVal (-1)],VectorVal [IntegerVal 127,IntegerVal (-128),IntegerVal (-18),IntegerVal (-1),IntegerVal 0,IntegerVal 127,IntegerVal (-8),IntegerVal 0]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s8(UINT64_C(0xff807fff808000ff));
      arg2 = vcreate_s8(UINT64_C(0x00f87f00ffee807f));
      clear_neon_saturated();
      //  Expect: "result" = ffbc7fffbfb7c03f
      result = vhadd_s8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s8(result), 0);
      exp = UINT64_C(0xffbc7fffbfb7c03f);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_48() {

{
   {
      int16x4_t arg1;
      int16x4_t arg2;
      int16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"halving_add\", fnname = \"vhadd_s16\", rettype = \"int16x4_t\", argtypes = \"[int16x4_t,int16x4_t]\", vals = [VectorVal [IntegerVal 32767,IntegerVal (-32768),IntegerVal 0,IntegerVal (-32768)],VectorVal [IntegerVal 32767,IntegerVal (-32768),IntegerVal (-32768),IntegerVal (-13073)]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s16(UINT64_C(0x8000000080007fff));
      arg2 = vcreate_s16(UINT64_C(0xccef800080007fff));
      clear_neon_saturated();
      //  Expect: "result" = a677c00080007fff
      result = vhadd_s16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s16(result), 0);
      exp = UINT64_C(0xa677c00080007fff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_49() {

{
   {
      int32x2_t arg1;
      int32x2_t arg2;
      int32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"halving_add\", fnname = \"vhadd_s32\", rettype = \"int32x2_t\", argtypes = \"[int32x2_t,int32x2_t]\", vals = [VectorVal [IntegerVal 2147436585,IntegerVal (-65536)],VectorVal [IntegerVal (-2147450881),IntegerVal (-1070553660)]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s32(UINT64_C(0xffff00007fff4829));
      arg2 = vcreate_s32(UINT64_C(0xc030a5c480007fff));
      clear_neon_saturated();
      //  Expect: "result" = e017d2e2ffffe414
      result = vhadd_s32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s32(result), 0);
      exp = UINT64_C(0xe017d2e2ffffe414);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_50() {

{
   {
      uint8x8_t arg1;
      uint8x8_t arg2;
      uint8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"halving_add\", fnname = \"vhadd_u8\", rettype = \"uint8x8_t\", argtypes = \"[uint8x8_t,uint8x8_t]\", vals = [VectorVal [IntegerVal 128,IntegerVal 128,IntegerVal 161,IntegerVal 255,IntegerVal 255,IntegerVal 127,IntegerVal 25,IntegerVal 3],VectorVal [IntegerVal 127,IntegerVal 127,IntegerVal 128,IntegerVal 128,IntegerVal 0,IntegerVal 127,IntegerVal 128,IntegerVal 127]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u8(UINT64_C(0x03197fffffa18080));
      arg2 = vcreate_u8(UINT64_C(0x7f807f0080807f7f));
      clear_neon_saturated();
      //  Expect: "result" = 414c7f7fbf907f7f
      result = vhadd_u8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u8(result), 0);
      exp = UINT64_C(0x414c7f7fbf907f7f);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_51() {

{
   {
      uint16x4_t arg1;
      uint16x4_t arg2;
      uint16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"halving_add\", fnname = \"vhadd_u16\", rettype = \"uint16x4_t\", argtypes = \"[uint16x4_t,uint16x4_t]\", vals = [VectorVal [IntegerVal 0,IntegerVal 32767,IntegerVal 44580,IntegerVal 32767],VectorVal [IntegerVal 32768,IntegerVal 32768,IntegerVal 24268,IntegerVal 32767]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u16(UINT64_C(0x7fffae247fff0000));
      arg2 = vcreate_u16(UINT64_C(0x7fff5ecc80008000));
      clear_neon_saturated();
      //  Expect: "result" = 7fff86787fff4000
      result = vhadd_u16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u16(result), 0);
      exp = UINT64_C(0x7fff86787fff4000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_52() {

{
   {
      uint32x2_t arg1;
      uint32x2_t arg2;
      uint32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"halving_add\", fnname = \"vhadd_u32\", rettype = \"uint32x2_t\", argtypes = \"[uint32x2_t,uint32x2_t]\", vals = [VectorVal [IntegerVal 65535,IntegerVal 4294967295],VectorVal [IntegerVal 34124,IntegerVal 2147483648]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u32(UINT64_C(0xffffffff0000ffff));
      arg2 = vcreate_u32(UINT64_C(0x800000000000854c));
      clear_neon_saturated();
      //  Expect: "result" = bfffffff0000c2a5
      result = vhadd_u32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u32(result), 0);
      exp = UINT64_C(0xbfffffff0000c2a5);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_53() {

{
   {
      int8x16_t arg1;
      int8x16_t arg2;
      int8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"halving_add\", fnname = \"vhaddq_s8\", rettype = \"int8x16_t\", argtypes = \"[int8x16_t,int8x16_t]\", vals = [VectorVal [IntegerVal 0,IntegerVal (-1),IntegerVal (-1),IntegerVal 0,IntegerVal 39,IntegerVal (-128),IntegerVal (-1),IntegerVal (-128),IntegerVal 127,IntegerVal (-48),IntegerVal (-128),IntegerVal (-15),IntegerVal (-14),IntegerVal (-1),IntegerVal 127,IntegerVal (-128)],VectorVal [IntegerVal (-49),IntegerVal 99,IntegerVal 127,IntegerVal (-128),IntegerVal 0,IntegerVal 127,IntegerVal (-128),IntegerVal (-1),IntegerVal (-1),IntegerVal (-1),IntegerVal (-128),IntegerVal 1,IntegerVal (-82),IntegerVal (-97),IntegerVal (-128),IntegerVal 127]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s8(vcreate_s8(UINT64_C(0x80ff802700ffff00)),
                         vcreate_s8(UINT64_C(0x807ffff2f180d07f)));
      arg2 = vcombine_s8(vcreate_s8(UINT64_C(0xff807f00807f63cf)),
                         vcreate_s8(UINT64_C(0x7f809fae0180ffff)));
      clear_neon_saturated();
      //  Expect: "result" = ffffcfd0f980e73fbfbfff13c03f31e7
      result = vhaddq_s8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result), 0);
         exp = UINT64_C(0xbfbfff13c03f31e7);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result), 1);
         exp = UINT64_C(0xffffcfd0f980e73f);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_54() {

{
   {
      int16x8_t arg1;
      int16x8_t arg2;
      int16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"halving_add\", fnname = \"vhaddq_s16\", rettype = \"int16x8_t\", argtypes = \"[int16x8_t,int16x8_t]\", vals = [VectorVal [IntegerVal (-10930),IntegerVal (-32768),IntegerVal (-32768),IntegerVal 32767,IntegerVal (-1),IntegerVal (-1),IntegerVal 32767,IntegerVal 32767],VectorVal [IntegerVal (-4983),IntegerVal 32767,IntegerVal 0,IntegerVal 18180,IntegerVal (-32768),IntegerVal (-1),IntegerVal 32767,IntegerVal 0]], start_saturated = True}";
      int reported = 0;
      arg1 = vcombine_s16(vcreate_s16(UINT64_C(0x7fff80008000d54e)),
                          vcreate_s16(UINT64_C(0x7fff7fffffffffff)));
      arg2 = vcombine_s16(vcreate_s16(UINT64_C(0x470400007fffec89)),
                          vcreate_s16(UINT64_C(0x00007fffffff8000)));
      set_neon_saturated();
      //  Expect: "result" = 3fff7fffffffbfff6381c000ffffe0eb
      result = vhaddq_s16(arg1, arg2);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 0);
         exp = UINT64_C(0x6381c000ffffe0eb);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 1);
         exp = UINT64_C(0x3fff7fffffffbfff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_55() {

{
   {
      int32x4_t arg1;
      int32x4_t arg2;
      int32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"halving_add\", fnname = \"vhaddq_s32\", rettype = \"int32x4_t\", argtypes = \"[int32x4_t,int32x4_t]\", vals = [VectorVal [IntegerVal (-2147483648),IntegerVal 714,IntegerVal 2147450880,IntegerVal (-2147418113)],VectorVal [IntegerVal 0,IntegerVal (-1488453632),IntegerVal (-32768),IntegerVal (-65536)]], start_saturated = True}";
      int reported = 0;
      arg1 = vcombine_s32(vcreate_s32(UINT64_C(0x000002ca80000000)),
                          vcreate_s32(UINT64_C(0x8000ffff7fff8000)));
      arg2 = vcombine_s32(vcreate_s32(UINT64_C(0xa748000000000000)),
                          vcreate_s32(UINT64_C(0xffff0000ffff8000)));
      set_neon_saturated();
      //  Expect: "result" = bfffffff3fff8000d3a40165c0000000
      result = vhaddq_s32(arg1, arg2);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 0);
         exp = UINT64_C(0xd3a40165c0000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 1);
         exp = UINT64_C(0xbfffffff3fff8000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_56() {

{
   {
      uint8x16_t arg1;
      uint8x16_t arg2;
      uint8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"halving_add\", fnname = \"vhaddq_u8\", rettype = \"uint8x16_t\", argtypes = \"[uint8x16_t,uint8x16_t]\", vals = [VectorVal [IntegerVal 128,IntegerVal 0,IntegerVal 243,IntegerVal 127,IntegerVal 255,IntegerVal 128,IntegerVal 255,IntegerVal 127,IntegerVal 127,IntegerVal 128,IntegerVal 101,IntegerVal 0,IntegerVal 0,IntegerVal 127,IntegerVal 255,IntegerVal 127],VectorVal [IntegerVal 128,IntegerVal 0,IntegerVal 197,IntegerVal 128,IntegerVal 255,IntegerVal 0,IntegerVal 128,IntegerVal 127,IntegerVal 122,IntegerVal 128,IntegerVal 0,IntegerVal 255,IntegerVal 0,IntegerVal 99,IntegerVal 0,IntegerVal 0]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u8(vcreate_u8(UINT64_C(0x7fff80ff7ff30080)),
                         vcreate_u8(UINT64_C(0x7fff7f000065807f)));
      arg2 = vcombine_u8(vcreate_u8(UINT64_C(0x7f8000ff80c50080)),
                         vcreate_u8(UINT64_C(0x00006300ff00807a)));
      clear_neon_saturated();
      //  Expect: "result" = 3f7f71007f32807c7fbf40ff7fdc0080
      result = vhaddq_u8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 0);
         exp = UINT64_C(0x7fbf40ff7fdc0080);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 1);
         exp = UINT64_C(0x3f7f71007f32807c);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_57() {

{
   {
      uint16x8_t arg1;
      uint16x8_t arg2;
      uint16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"halving_add\", fnname = \"vhaddq_u16\", rettype = \"uint16x8_t\", argtypes = \"[uint16x8_t,uint16x8_t]\", vals = [VectorVal [IntegerVal 0,IntegerVal 32768,IntegerVal 32767,IntegerVal 32767,IntegerVal 0,IntegerVal 32767,IntegerVal 65535,IntegerVal 65535],VectorVal [IntegerVal 43889,IntegerVal 32767,IntegerVal 32768,IntegerVal 32767,IntegerVal 55164,IntegerVal 32768,IntegerVal 0,IntegerVal 32767]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u16(vcreate_u16(UINT64_C(0x7fff7fff80000000)),
                          vcreate_u16(UINT64_C(0xffffffff7fff0000)));
      arg2 = vcombine_u16(vcreate_u16(UINT64_C(0x7fff80007fffab71)),
                          vcreate_u16(UINT64_C(0x7fff00008000d77c)));
      clear_neon_saturated();
      //  Expect: "result" = bfff7fff7fff6bbe7fff7fff7fff55b8
      result = vhaddq_u16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 0);
         exp = UINT64_C(0x7fff7fff7fff55b8);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 1);
         exp = UINT64_C(0xbfff7fff7fff6bbe);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_58() {

{
   {
      uint32x4_t arg1;
      uint32x4_t arg2;
      uint32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"halving_add\", fnname = \"vhaddq_u32\", rettype = \"uint32x4_t\", argtypes = \"[uint32x4_t,uint32x4_t]\", vals = [VectorVal [IntegerVal 4294934528,IntegerVal 2147514244,IntegerVal 65535,IntegerVal 492437503],VectorVal [IntegerVal 4294934527,IntegerVal 2147516416,IntegerVal 2147483648,IntegerVal 2147549183]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u32(vcreate_u32(UINT64_C(0x80007784ffff8000)),
                          vcreate_u32(UINT64_C(0x1d59ffff0000ffff)));
      arg2 = vcombine_u32(vcreate_u32(UINT64_C(0x80008000ffff7fff)),
                          vcreate_u32(UINT64_C(0x8000ffff80000000)));
      clear_neon_saturated();
      //  Expect: "result" = 4ead7fff40007fff80007bc2ffff7fff
      result = vhaddq_u32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 0);
         exp = UINT64_C(0x80007bc2ffff7fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 1);
         exp = UINT64_C(0x4ead7fff40007fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_59() {

{
   {
      int8x8_t arg1;
      int8x8_t arg2;
      int8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"roundinghalving_add\", fnname = \"vrhadd_s8\", rettype = \"int8x8_t\", argtypes = \"[int8x8_t,int8x8_t]\", vals = [VectorVal [IntegerVal (-128),IntegerVal 127,IntegerVal 127,IntegerVal (-57),IntegerVal 127,IntegerVal (-1),IntegerVal 127,IntegerVal 127],VectorVal [IntegerVal (-128),IntegerVal 0,IntegerVal 0,IntegerVal (-1),IntegerVal (-1),IntegerVal 127,IntegerVal (-128),IntegerVal (-1)]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s8(UINT64_C(0x7f7fff7fc77f7f80));
      arg2 = vcreate_s8(UINT64_C(0xff807fffff000080));
      clear_neon_saturated();
      //  Expect: "result" = 3f003f3fe3404080
      result = vrhadd_s8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s8(result), 0);
      exp = UINT64_C(0x3f003f3fe3404080);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_60() {

{
   {
      int16x4_t arg1;
      int16x4_t arg2;
      int16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"roundinghalving_add\", fnname = \"vrhadd_s16\", rettype = \"int16x4_t\", argtypes = \"[int16x4_t,int16x4_t]\", vals = [VectorVal [IntegerVal (-1),IntegerVal 32767,IntegerVal 32767,IntegerVal (-26422)],VectorVal [IntegerVal 0,IntegerVal 32767,IntegerVal 0,IntegerVal (-32768)]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s16(UINT64_C(0x98ca7fff7fffffff));
      arg2 = vcreate_s16(UINT64_C(0x800000007fff0000));
      clear_neon_saturated();
      //  Expect: "result" = 8c6540007fff0000
      result = vrhadd_s16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s16(result), 0);
      exp = UINT64_C(0x8c6540007fff0000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_61() {

{
   {
      int32x2_t arg1;
      int32x2_t arg2;
      int32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"roundinghalving_add\", fnname = \"vrhadd_s32\", rettype = \"int32x2_t\", argtypes = \"[int32x2_t,int32x2_t]\", vals = [VectorVal [IntegerVal 0,IntegerVal 1342504959],VectorVal [IntegerVal 1437925376,IntegerVal 0]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s32(UINT64_C(0x5004ffff00000000));
      arg2 = vcreate_s32(UINT64_C(0x0000000055b50000));
      clear_neon_saturated();
      //  Expect: "result" = 280280002ada8000
      result = vrhadd_s32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s32(result), 0);
      exp = UINT64_C(0x280280002ada8000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_62() {

{
   {
      uint8x8_t arg1;
      uint8x8_t arg2;
      uint8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"roundinghalving_add\", fnname = \"vrhadd_u8\", rettype = \"uint8x8_t\", argtypes = \"[uint8x8_t,uint8x8_t]\", vals = [VectorVal [IntegerVal 255,IntegerVal 173,IntegerVal 255,IntegerVal 213,IntegerVal 0,IntegerVal 255,IntegerVal 127,IntegerVal 137],VectorVal [IntegerVal 128,IntegerVal 128,IntegerVal 0,IntegerVal 128,IntegerVal 128,IntegerVal 128,IntegerVal 139,IntegerVal 230]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u8(UINT64_C(0x897fff00d5ffadff));
      arg2 = vcreate_u8(UINT64_C(0xe68b808080008080));
      clear_neon_saturated();
      //  Expect: "result" = b885c040ab8097c0
      result = vrhadd_u8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u8(result), 0);
      exp = UINT64_C(0xb885c040ab8097c0);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_63() {

{
   {
      uint16x4_t arg1;
      uint16x4_t arg2;
      uint16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"roundinghalving_add\", fnname = \"vrhadd_u16\", rettype = \"uint16x4_t\", argtypes = \"[uint16x4_t,uint16x4_t]\", vals = [VectorVal [IntegerVal 65535,IntegerVal 0,IntegerVal 65535,IntegerVal 32768],VectorVal [IntegerVal 32767,IntegerVal 0,IntegerVal 65535,IntegerVal 0]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u16(UINT64_C(0x8000ffff0000ffff));
      arg2 = vcreate_u16(UINT64_C(0x0000ffff00007fff));
      clear_neon_saturated();
      //  Expect: "result" = 4000ffff0000bfff
      result = vrhadd_u16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u16(result), 0);
      exp = UINT64_C(0x4000ffff0000bfff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_64() {

{
   {
      uint32x2_t arg1;
      uint32x2_t arg2;
      uint32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"roundinghalving_add\", fnname = \"vrhadd_u32\", rettype = \"uint32x2_t\", argtypes = \"[uint32x2_t,uint32x2_t]\", vals = [VectorVal [IntegerVal 2147549183,IntegerVal 32768],VectorVal [IntegerVal 2316337151,IntegerVal 2147516415]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u32(UINT64_C(0x000080008000ffff));
      arg2 = vcreate_u32(UINT64_C(0x80007fff8a107fff));
      clear_neon_saturated();
      //  Expect: "result" = 400080008508bfff
      result = vrhadd_u32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u32(result), 0);
      exp = UINT64_C(0x400080008508bfff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_65() {

{
   {
      int8x16_t arg1;
      int8x16_t arg2;
      int8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"roundinghalving_add\", fnname = \"vrhaddq_s8\", rettype = \"int8x16_t\", argtypes = \"[int8x16_t,int8x16_t]\", vals = [VectorVal [IntegerVal (-59),IntegerVal (-128),IntegerVal 0,IntegerVal 0,IntegerVal 43,IntegerVal (-25),IntegerVal (-1),IntegerVal 80,IntegerVal (-1),IntegerVal 0,IntegerVal 0,IntegerVal 0,IntegerVal (-1),IntegerVal (-22),IntegerVal (-71),IntegerVal (-1)],VectorVal [IntegerVal (-1),IntegerVal 127,IntegerVal 0,IntegerVal (-1),IntegerVal (-128),IntegerVal 127,IntegerVal 127,IntegerVal 0,IntegerVal (-1),IntegerVal 0,IntegerVal 127,IntegerVal (-128),IntegerVal (-1),IntegerVal (-1),IntegerVal (-64),IntegerVal 127]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s8(vcreate_s8(UINT64_C(0x50ffe72b000080c5)),
                         vcreate_s8(UINT64_C(0xffb9eaff000000ff)));
      arg2 = vcombine_s8(vcreate_s8(UINT64_C(0x007f7f80ff007fff)),
                         vcreate_s8(UINT64_C(0x7fc0ffff807f00ff)));
      clear_neon_saturated();
      //  Expect: "result" = 3fbdf5ffc04000ff283f33d6000000e2
      result = vrhaddq_s8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result), 0);
         exp = UINT64_C(0x283f33d6000000e2);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result), 1);
         exp = UINT64_C(0x3fbdf5ffc04000ff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_66() {

{
   {
      int16x8_t arg1;
      int16x8_t arg2;
      int16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"roundinghalving_add\", fnname = \"vrhaddq_s16\", rettype = \"int16x8_t\", argtypes = \"[int16x8_t,int16x8_t]\", vals = [VectorVal [IntegerVal (-32768),IntegerVal (-32768),IntegerVal 0,IntegerVal 0,IntegerVal (-1),IntegerVal (-1),IntegerVal 3035,IntegerVal (-1)],VectorVal [IntegerVal 0,IntegerVal (-1),IntegerVal (-1),IntegerVal 0,IntegerVal (-23325),IntegerVal 0,IntegerVal (-32768),IntegerVal 0]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s16(vcreate_s16(UINT64_C(0x0000000080008000)),
                          vcreate_s16(UINT64_C(0xffff0bdbffffffff)));
      arg2 = vcombine_s16(vcreate_s16(UINT64_C(0x0000ffffffff0000)),
                          vcreate_s16(UINT64_C(0x000080000000a4e3)));
      clear_neon_saturated();
      //  Expect: "result" = 0000c5ee0000d27100000000c000c000
      result = vrhaddq_s16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 0);
         exp = UINT64_C(0x00000000c000c000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 1);
         exp = UINT64_C(0x0000c5ee0000d271);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_67() {

{
   {
      int32x4_t arg1;
      int32x4_t arg2;
      int32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"roundinghalving_add\", fnname = \"vrhaddq_s32\", rettype = \"int32x4_t\", argtypes = \"[int32x4_t,int32x4_t]\", vals = [VectorVal [IntegerVal 2147483647,IntegerVal (-2147475410),IntegerVal (-2147418113),IntegerVal 32768],VectorVal [IntegerVal 1718910975,IntegerVal 0,IntegerVal 2147483647,IntegerVal (-31899)]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s32(vcreate_s32(UINT64_C(0x8000202e7fffffff)),
                          vcreate_s32(UINT64_C(0x000080008000ffff)));
      arg2 = vcombine_s32(vcreate_s32(UINT64_C(0x0000000066747fff)),
                          vcreate_s32(UINT64_C(0xffff83657fffffff)));
      clear_neon_saturated();
      //  Expect: "result" = 000001b300007fffc0001017733a3fff
      result = vrhaddq_s32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 0);
         exp = UINT64_C(0xc0001017733a3fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 1);
         exp = UINT64_C(0x000001b300007fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_68() {

{
   {
      uint8x16_t arg1;
      uint8x16_t arg2;
      uint8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"roundinghalving_add\", fnname = \"vrhaddq_u8\", rettype = \"uint8x16_t\", argtypes = \"[uint8x16_t,uint8x16_t]\", vals = [VectorVal [IntegerVal 127,IntegerVal 210,IntegerVal 221,IntegerVal 128,IntegerVal 90,IntegerVal 19,IntegerVal 100,IntegerVal 0,IntegerVal 255,IntegerVal 127,IntegerVal 128,IntegerVal 128,IntegerVal 142,IntegerVal 140,IntegerVal 127,IntegerVal 128],VectorVal [IntegerVal 127,IntegerVal 255,IntegerVal 128,IntegerVal 127,IntegerVal 127,IntegerVal 128,IntegerVal 125,IntegerVal 0,IntegerVal 127,IntegerVal 0,IntegerVal 128,IntegerVal 19,IntegerVal 127,IntegerVal 128,IntegerVal 255,IntegerVal 128]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u8(vcreate_u8(UINT64_C(0x0064135a80ddd27f)),
                         vcreate_u8(UINT64_C(0x807f8c8e80807fff)));
      arg2 = vcombine_u8(vcreate_u8(UINT64_C(0x007d807f7f80ff7f)),
                         vcreate_u8(UINT64_C(0x80ff807f1380007f)));
      clear_neon_saturated();
      //  Expect: "result" = 80bf86874a8040bf00714a6d80afe97f
      result = vrhaddq_u8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 0);
         exp = UINT64_C(0x00714a6d80afe97f);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 1);
         exp = UINT64_C(0x80bf86874a8040bf);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_69() {

{
   {
      uint16x8_t arg1;
      uint16x8_t arg2;
      uint16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"roundinghalving_add\", fnname = \"vrhaddq_u16\", rettype = \"uint16x8_t\", argtypes = \"[uint16x8_t,uint16x8_t]\", vals = [VectorVal [IntegerVal 0,IntegerVal 0,IntegerVal 0,IntegerVal 32767,IntegerVal 0,IntegerVal 0,IntegerVal 65535,IntegerVal 65535],VectorVal [IntegerVal 32767,IntegerVal 46138,IntegerVal 65535,IntegerVal 0,IntegerVal 0,IntegerVal 7927,IntegerVal 65535,IntegerVal 47148]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u16(vcreate_u16(UINT64_C(0x7fff000000000000)),
                          vcreate_u16(UINT64_C(0xffffffff00000000)));
      arg2 = vcombine_u16(vcreate_u16(UINT64_C(0x0000ffffb43a7fff)),
                          vcreate_u16(UINT64_C(0xb82cffff1ef70000)));
      clear_neon_saturated();
      //  Expect: "result" = dc16ffff0f7c0000400080005a1d4000
      result = vrhaddq_u16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 0);
         exp = UINT64_C(0x400080005a1d4000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 1);
         exp = UINT64_C(0xdc16ffff0f7c0000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_70() {

{
   {
      uint32x4_t arg1;
      uint32x4_t arg2;
      uint32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"roundinghalving_add\", fnname = \"vrhaddq_u32\", rettype = \"uint32x4_t\", argtypes = \"[uint32x4_t,uint32x4_t]\", vals = [VectorVal [IntegerVal 3018883072,IntegerVal 4294967295,IntegerVal 4294967295,IntegerVal 0],VectorVal [IntegerVal 22629,IntegerVal 32768,IntegerVal 2147516416,IntegerVal 805896192]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u32(vcreate_u32(UINT64_C(0xffffffffb3f08000)),
                          vcreate_u32(UINT64_C(0x00000000ffffffff)));
      arg2 = vcombine_u32(vcreate_u32(UINT64_C(0x0000800000005865)),
                          vcreate_u32(UINT64_C(0x3009000080008000)));
      clear_neon_saturated();
      //  Expect: "result" = 18048000c00040008000400059f86c33
      result = vrhaddq_u32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 0);
         exp = UINT64_C(0x8000400059f86c33);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 1);
         exp = UINT64_C(0x18048000c0004000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_71() {

{
   {
      int8x8_t arg1;
      int8x8_t arg2;
      int8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"saturating_add\", fnname = \"vqadd_s8\", rettype = \"int8x8_t\", argtypes = \"[int8x8_t,int8x8_t]\", vals = [VectorVal [IntegerVal 52,IntegerVal (-1),IntegerVal (-128),IntegerVal 74,IntegerVal 127,IntegerVal (-1),IntegerVal 84,IntegerVal 127],VectorVal [IntegerVal 0,IntegerVal (-1),IntegerVal 71,IntegerVal (-1),IntegerVal (-128),IntegerVal (-128),IntegerVal 0,IntegerVal 55]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s8(UINT64_C(0x7f54ff7f4a80ff34));
      arg2 = vcreate_s8(UINT64_C(0x37008080ff47ff00));
      clear_neon_saturated();
      //  Expect: "result" = 7f5480ff49c7fe34
      result = vqadd_s8(arg1, arg2);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s8(result), 0);
      exp = UINT64_C(0x7f5480ff49c7fe34);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_72() {

{
   {
      int16x4_t arg1;
      int16x4_t arg2;
      int16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"saturating_add\", fnname = \"vqadd_s16\", rettype = \"int16x4_t\", argtypes = \"[int16x4_t,int16x4_t]\", vals = [VectorVal [IntegerVal 32767,IntegerVal 32767,IntegerVal 32767,IntegerVal (-32768)],VectorVal [IntegerVal 24380,IntegerVal 0,IntegerVal 0,IntegerVal 0]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s16(UINT64_C(0x80007fff7fff7fff));
      arg2 = vcreate_s16(UINT64_C(0x0000000000005f3c));
      clear_neon_saturated();
      //  Expect: "result" = 80007fff7fff7fff
      result = vqadd_s16(arg1, arg2);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s16(result), 0);
      exp = UINT64_C(0x80007fff7fff7fff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_73() {

{
   {
      int32x2_t arg1;
      int32x2_t arg2;
      int32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"saturating_add\", fnname = \"vqadd_s32\", rettype = \"int32x2_t\", argtypes = \"[int32x2_t,int32x2_t]\", vals = [VectorVal [IntegerVal 32768,IntegerVal 2147423842],VectorVal [IntegerVal 65535,IntegerVal 414351360]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s32(UINT64_C(0x7fff166200008000));
      arg2 = vcreate_s32(UINT64_C(0x18b280000000ffff));
      clear_neon_saturated();
      //  Expect: "result" = 7fffffff00017fff
      result = vqadd_s32(arg1, arg2);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s32(result), 0);
      exp = UINT64_C(0x7fffffff00017fff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_74() {

{
   {
      int64x1_t arg1;
      int64x1_t arg2;
      int64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"saturating_add\", fnname = \"vqadd_s64\", rettype = \"int64x1_t\", argtypes = \"[int64x1_t,int64x1_t]\", vals = [VectorVal [IntegerVal 101741332824063],VectorVal [IntegerVal (-140739635806209)]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s64(UINT64_C(0x00005c8880007fff));
      arg2 = vcreate_s64(UINT64_C(0xffff7fff80007fff));
      clear_neon_saturated();
      //  Expect: "result" = ffffdc880000fffe
      result = vqadd_s64(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s64(result), 0);
      exp = UINT64_C(0xffffdc880000fffe);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_75() {

{
   {
      uint8x8_t arg1;
      uint8x8_t arg2;
      uint8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"saturating_add\", fnname = \"vqadd_u8\", rettype = \"uint8x8_t\", argtypes = \"[uint8x8_t,uint8x8_t]\", vals = [VectorVal [IntegerVal 127,IntegerVal 127,IntegerVal 45,IntegerVal 127,IntegerVal 0,IntegerVal 0,IntegerVal 128,IntegerVal 128],VectorVal [IntegerVal 74,IntegerVal 255,IntegerVal 0,IntegerVal 82,IntegerVal 172,IntegerVal 128,IntegerVal 255,IntegerVal 3]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u8(UINT64_C(0x808000007f2d7f7f));
      arg2 = vcreate_u8(UINT64_C(0x03ff80ac5200ff4a));
      clear_neon_saturated();
      //  Expect: "result" = 83ff80acd12dffc9
      result = vqadd_u8(arg1, arg2);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u8(result), 0);
      exp = UINT64_C(0x83ff80acd12dffc9);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_76() {

{
   {
      uint16x4_t arg1;
      uint16x4_t arg2;
      uint16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"saturating_add\", fnname = \"vqadd_u16\", rettype = \"uint16x4_t\", argtypes = \"[uint16x4_t,uint16x4_t]\", vals = [VectorVal [IntegerVal 54547,IntegerVal 48298,IntegerVal 65535,IntegerVal 32767],VectorVal [IntegerVal 0,IntegerVal 32768,IntegerVal 1654,IntegerVal 32767]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u16(UINT64_C(0x7fffffffbcaad513));
      arg2 = vcreate_u16(UINT64_C(0x7fff067680000000));
      clear_neon_saturated();
      //  Expect: "result" = fffeffffffffd513
      result = vqadd_u16(arg1, arg2);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u16(result), 0);
      exp = UINT64_C(0xfffeffffffffd513);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_77() {

{
   {
      uint32x2_t arg1;
      uint32x2_t arg2;
      uint32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"saturating_add\", fnname = \"vqadd_u32\", rettype = \"uint32x2_t\", argtypes = \"[uint32x2_t,uint32x2_t]\", vals = [VectorVal [IntegerVal 2571862015,IntegerVal 37985380],VectorVal [IntegerVal 2147450879,IntegerVal 4294901760]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u32(UINT64_C(0x02439c64994b7fff));
      arg2 = vcreate_u32(UINT64_C(0xffff00007fff7fff));
      clear_neon_saturated();
      //  Expect: "result" = ffffffffffffffff
      result = vqadd_u32(arg1, arg2);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u32(result), 0);
      exp = UINT64_C(0xffffffffffffffff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_78() {

{
   {
      uint64x1_t arg1;
      uint64x1_t arg2;
      uint64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"saturating_add\", fnname = \"vqadd_u64\", rettype = \"uint64x1_t\", argtypes = \"[uint64x1_t,uint64x1_t]\", vals = [VectorVal [IntegerVal 9223372033579319295],VectorVal [IntegerVal 2147450880]], start_saturated = True}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u64(UINT64_C(0x7fffffff3cc47fff));
      arg2 = vcreate_u64(UINT64_C(0x000000007fff8000));
      set_neon_saturated();
      //  Expect: "result" = 7fffffffbcc3ffff
      result = vqadd_u64(arg1, arg2);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      got = vget_lane_u64(result, 0);
      exp = UINT64_C(0x7fffffffbcc3ffff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_79() {

{
   {
      int8x16_t arg1;
      int8x16_t arg2;
      int8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"saturating_add\", fnname = \"vqaddq_s8\", rettype = \"int8x16_t\", argtypes = \"[int8x16_t,int8x16_t]\", vals = [VectorVal [IntegerVal (-1),IntegerVal (-1),IntegerVal (-1),IntegerVal 0,IntegerVal 37,IntegerVal 127,IntegerVal (-128),IntegerVal 127,IntegerVal 0,IntegerVal (-1),IntegerVal 0,IntegerVal 0,IntegerVal (-1),IntegerVal 0,IntegerVal 127,IntegerVal 59],VectorVal [IntegerVal (-128),IntegerVal (-1),IntegerVal 127,IntegerVal (-45),IntegerVal 0,IntegerVal 0,IntegerVal (-1),IntegerVal 127,IntegerVal (-128),IntegerVal 127,IntegerVal (-128),IntegerVal 127,IntegerVal 0,IntegerVal (-128),IntegerVal (-122),IntegerVal (-128)]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s8(vcreate_s8(UINT64_C(0x7f807f2500ffffff)),
                         vcreate_s8(UINT64_C(0x3b7f00ff0000ff00)));
      arg2 = vcombine_s8(vcreate_s8(UINT64_C(0x7fff0000d37fff80)),
                         vcreate_s8(UINT64_C(0x808680007f807f80)));
      clear_neon_saturated();
      //  Expect: "result" = bb0580ff7f807e807f807f25d37efe80
      result = vqaddq_s8(arg1, arg2);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result), 0);
         exp = UINT64_C(0x7f807f25d37efe80);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result), 1);
         exp = UINT64_C(0xbb0580ff7f807e80);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_80() {

{
   {
      int16x8_t arg1;
      int16x8_t arg2;
      int16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"saturating_add\", fnname = \"vqaddq_s16\", rettype = \"int16x8_t\", argtypes = \"[int16x8_t,int16x8_t]\", vals = [VectorVal [IntegerVal (-9571),IntegerVal (-7257),IntegerVal 0,IntegerVal 32767,IntegerVal (-32768),IntegerVal 0,IntegerVal 0,IntegerVal 27648],VectorVal [IntegerVal (-3070),IntegerVal 0,IntegerVal 32767,IntegerVal (-1),IntegerVal 0,IntegerVal 32767,IntegerVal (-32768),IntegerVal (-16090)]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s16(vcreate_s16(UINT64_C(0x7fff0000e3a7da9d)),
                          vcreate_s16(UINT64_C(0x6c00000000008000)));
      arg2 = vcombine_s16(vcreate_s16(UINT64_C(0xffff7fff0000f402)),
                          vcreate_s16(UINT64_C(0xc12680007fff0000)));
      clear_neon_saturated();
      //  Expect: "result" = 2d2680007fff80007ffe7fffe3a7ce9f
      result = vqaddq_s16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 0);
         exp = UINT64_C(0x7ffe7fffe3a7ce9f);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 1);
         exp = UINT64_C(0x2d2680007fff8000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_81() {

{
   {
      int32x4_t arg1;
      int32x4_t arg2;
      int32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"saturating_add\", fnname = \"vqaddq_s32\", rettype = \"int32x4_t\", argtypes = \"[int32x4_t,int32x4_t]\", vals = [VectorVal [IntegerVal (-1118142464),IntegerVal (-1),IntegerVal (-32769),IntegerVal (-2147465401)],VectorVal [IntegerVal (-2147483648),IntegerVal (-2147483648),IntegerVal 20743,IntegerVal 2147450879]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s32(vcreate_s32(UINT64_C(0xffffffffbd5a8000)),
                          vcreate_s32(UINT64_C(0x80004747ffff7fff)));
      arg2 = vcombine_s32(vcreate_s32(UINT64_C(0x8000000080000000)),
                          vcreate_s32(UINT64_C(0x7fff7fff00005107)));
      clear_neon_saturated();
      //  Expect: "result" = ffffc746ffffd1068000000080000000
      result = vqaddq_s32(arg1, arg2);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 0);
         exp = UINT64_C(0x8000000080000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 1);
         exp = UINT64_C(0xffffc746ffffd106);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_82() {

{
   {
      int64x2_t arg1;
      int64x2_t arg2;
      int64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"saturating_add\", fnname = \"vqaddq_s64\", rettype = \"int64x2_t\", argtypes = \"[int64x2_t,int64x2_t]\", vals = [VectorVal [IntegerVal (-9223231303564460032),IntegerVal 2147516416],VectorVal [IntegerVal 1646653125135663104,IntegerVal 9223231297218871296]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s64(vcreate_s64(UINT64_C(0x80007fff05c70000)),
                          vcreate_s64(UINT64_C(0x0000000080008000)));
      arg2 = vcombine_s64(vcreate_s64(UINT64_C(0x16da164affff8000)),
                          vcreate_s64(UINT64_C(0x7fff7fff7fff0000)));
      clear_neon_saturated();
      //  Expect: "result" = 7fff7fffffff800096da964a05c68000
      result = vqaddq_s64(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 0);
         exp = UINT64_C(0x96da964a05c68000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 1);
         exp = UINT64_C(0x7fff7fffffff8000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_83() {

{
   {
      uint8x16_t arg1;
      uint8x16_t arg2;
      uint8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"saturating_add\", fnname = \"vqaddq_u8\", rettype = \"uint8x16_t\", argtypes = \"[uint8x16_t,uint8x16_t]\", vals = [VectorVal [IntegerVal 0,IntegerVal 128,IntegerVal 92,IntegerVal 255,IntegerVal 0,IntegerVal 104,IntegerVal 128,IntegerVal 128,IntegerVal 128,IntegerVal 127,IntegerVal 207,IntegerVal 125,IntegerVal 128,IntegerVal 255,IntegerVal 104,IntegerVal 255],VectorVal [IntegerVal 0,IntegerVal 128,IntegerVal 34,IntegerVal 128,IntegerVal 255,IntegerVal 127,IntegerVal 128,IntegerVal 127,IntegerVal 128,IntegerVal 143,IntegerVal 128,IntegerVal 128,IntegerVal 11,IntegerVal 255,IntegerVal 128,IntegerVal 193]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u8(vcreate_u8(UINT64_C(0x80806800ff5c8000)),
                         vcreate_u8(UINT64_C(0xff68ff807dcf7f80)));
      arg2 = vcombine_u8(vcreate_u8(UINT64_C(0x7f807fff80228000)),
                         vcreate_u8(UINT64_C(0xc180ff0b80808f80)));
      clear_neon_saturated();
      //  Expect: "result" = ffe8ff8bfdffffffffffe7ffff7eff00
      result = vqaddq_u8(arg1, arg2);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 0);
         exp = UINT64_C(0xffffe7ffff7eff00);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 1);
         exp = UINT64_C(0xffe8ff8bfdffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_84() {

{
   {
      uint16x8_t arg1;
      uint16x8_t arg2;
      uint16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"saturating_add\", fnname = \"vqaddq_u16\", rettype = \"uint16x8_t\", argtypes = \"[uint16x8_t,uint16x8_t]\", vals = [VectorVal [IntegerVal 50464,IntegerVal 54499,IntegerVal 32768,IntegerVal 48249,IntegerVal 65535,IntegerVal 32767,IntegerVal 65535,IntegerVal 65535],VectorVal [IntegerVal 32767,IntegerVal 0,IntegerVal 65535,IntegerVal 44826,IntegerVal 65535,IntegerVal 32768,IntegerVal 32768,IntegerVal 26498]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u16(vcreate_u16(UINT64_C(0xbc798000d4e3c520)),
                          vcreate_u16(UINT64_C(0xffffffff7fffffff)));
      arg2 = vcombine_u16(vcreate_u16(UINT64_C(0xaf1affff00007fff)),
                          vcreate_u16(UINT64_C(0x678280008000ffff)));
      clear_neon_saturated();
      //  Expect: "result" = ffffffffffffffffffffffffd4e3ffff
      result = vqaddq_u16(arg1, arg2);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 0);
         exp = UINT64_C(0xffffffffd4e3ffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 1);
         exp = UINT64_C(0xffffffffffffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_85() {

{
   {
      uint32x4_t arg1;
      uint32x4_t arg2;
      uint32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"saturating_add\", fnname = \"vqaddq_u32\", rettype = \"uint32x4_t\", argtypes = \"[uint32x4_t,uint32x4_t]\", vals = [VectorVal [IntegerVal 1560346623,IntegerVal 62973,IntegerVal 2147549183,IntegerVal 4294901760],VectorVal [IntegerVal 4294901760,IntegerVal 4294901760,IntegerVal 2147483648,IntegerVal 32768]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u32(vcreate_u32(UINT64_C(0x0000f5fd5d00ffff)),
                          vcreate_u32(UINT64_C(0xffff00008000ffff)));
      arg2 = vcombine_u32(vcreate_u32(UINT64_C(0xffff0000ffff0000)),
                          vcreate_u32(UINT64_C(0x0000800080000000)));
      clear_neon_saturated();
      //  Expect: "result" = ffff8000fffffffffffff5fdffffffff
      result = vqaddq_u32(arg1, arg2);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 0);
         exp = UINT64_C(0xfffff5fdffffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 1);
         exp = UINT64_C(0xffff8000ffffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_86() {

{
   {
      uint64x2_t arg1;
      uint64x2_t arg2;
      uint64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"saturating_add\", fnname = \"vqaddq_u64\", rettype = \"uint64x2_t\", argtypes = \"[uint64x2_t,uint64x2_t]\", vals = [VectorVal [IntegerVal 18446545640574386175,IntegerVal 13614269357998702592],VectorVal [IntegerVal 9223512771124854783,IntegerVal 9223175971597680640]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u64(vcreate_u64(UINT64_C(0xffff4b86af777fff)),
                          vcreate_u64(UINT64_C(0xbcef99d97fff8000)));
      arg2 = vcombine_u64(vcreate_u64(UINT64_C(0x80007fff402cffff)),
                          vcreate_u64(UINT64_C(0x7fff4dadffff8000)));
      clear_neon_saturated();
      //  Expect: "result" = ffffffffffffffffffffffffffffffff
      result = vqaddq_u64(arg1, arg2);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 0);
         exp = UINT64_C(0xffffffffffffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 1);
         exp = UINT64_C(0xffffffffffffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_87() {

{
   {
      int8x8_t arg1;
      uint8x8_t arg2;
      int8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"saturating_add\", fnname = \"vuqadd_s8\", rettype = \"int8x8_t\", argtypes = \"[int8x8_t,uint8x8_t]\", vals = [VectorVal [IntegerVal 21,IntegerVal 39,IntegerVal 13,IntegerVal 127,IntegerVal 103,IntegerVal 127,IntegerVal 0,IntegerVal 127],VectorVal [IntegerVal 250,IntegerVal 0,IntegerVal 0,IntegerVal 255,IntegerVal 97,IntegerVal 180,IntegerVal 0,IntegerVal 127]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s8(UINT64_C(0x7f007f677f0d2715));
      arg2 = vcreate_u8(UINT64_C(0x7f00b461ff0000fa));
      clear_neon_saturated();
      //  Expect: "result" = 7f007f7f7f0d277f
      result = vuqadd_s8(arg1, arg2);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s8(result), 0);
      exp = UINT64_C(0x7f007f7f7f0d277f);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_88() {

{
   {
      int16x4_t arg1;
      uint16x4_t arg2;
      int16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"saturating_add\", fnname = \"vuqadd_s16\", rettype = \"int16x4_t\", argtypes = \"[int16x4_t,uint16x4_t]\", vals = [VectorVal [IntegerVal (-1),IntegerVal (-1),IntegerVal (-16828),IntegerVal 29934],VectorVal [IntegerVal 65535,IntegerVal 18401,IntegerVal 10435,IntegerVal 65535]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s16(UINT64_C(0x74eebe44ffffffff));
      arg2 = vcreate_u16(UINT64_C(0xffff28c347e1ffff));
      clear_neon_saturated();
      //  Expect: "result" = 7fffe70747e07fff
      result = vuqadd_s16(arg1, arg2);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s16(result), 0);
      exp = UINT64_C(0x7fffe70747e07fff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_89() {

{
   {
      int32x2_t arg1;
      uint32x2_t arg2;
      int32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"saturating_add\", fnname = \"vuqadd_s32\", rettype = \"int32x2_t\", argtypes = \"[int32x2_t,uint32x2_t]\", vals = [VectorVal [IntegerVal 2147418112,IntegerVal 32768],VectorVal [IntegerVal 917864447,IntegerVal 2147549183]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s32(UINT64_C(0x000080007fff0000));
      arg2 = vcreate_u32(UINT64_C(0x8000ffff36b57fff));
      clear_neon_saturated();
      //  Expect: "result" = 7fffffff7fffffff
      result = vuqadd_s32(arg1, arg2);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s32(result), 0);
      exp = UINT64_C(0x7fffffff7fffffff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_90() {

{
   {
      int64x1_t arg1;
      uint64x1_t arg2;
      int64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"saturating_add\", fnname = \"vuqadd_s64\", rettype = \"int64x1_t\", argtypes = \"[int64x1_t,uint64x1_t]\", vals = [VectorVal [IntegerVal (-140737488420864)],VectorVal [IntegerVal 9223512770048196607]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s64(UINT64_C(0xffff7fffffff0000));
      arg2 = vcreate_u64(UINT64_C(0x80007fff00007fff));
      clear_neon_saturated();
      //  Expect: "result" = 7ffffffeffff7fff
      result = vuqadd_s64(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s64(result), 0);
      exp = UINT64_C(0x7ffffffeffff7fff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_91() {

{
   {
      uint8x8_t arg1;
      int8x8_t arg2;
      uint8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"saturating_add\", fnname = \"vsqadd_u8\", rettype = \"uint8x8_t\", argtypes = \"[uint8x8_t,int8x8_t]\", vals = [VectorVal [IntegerVal 127,IntegerVal 216,IntegerVal 255,IntegerVal 149,IntegerVal 255,IntegerVal 128,IntegerVal 222,IntegerVal 0],VectorVal [IntegerVal 127,IntegerVal 127,IntegerVal 0,IntegerVal 127,IntegerVal 0,IntegerVal 127,IntegerVal (-1),IntegerVal (-128)]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u8(UINT64_C(0x00de80ff95ffd87f));
      arg2 = vcreate_s8(UINT64_C(0x80ff7f007f007f7f));
      clear_neon_saturated();
      //  Expect: "result" = 00ddfffffffffffe
      result = vsqadd_u8(arg1, arg2);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u8(result), 0);
      exp = UINT64_C(0x00ddfffffffffffe);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_92() {

{
   {
      uint16x4_t arg1;
      int16x4_t arg2;
      uint16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"saturating_add\", fnname = \"vsqadd_u16\", rettype = \"uint16x4_t\", argtypes = \"[uint16x4_t,int16x4_t]\", vals = [VectorVal [IntegerVal 65535,IntegerVal 32767,IntegerVal 25236,IntegerVal 65535],VectorVal [IntegerVal (-1),IntegerVal 14475,IntegerVal 32767,IntegerVal 32767]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u16(UINT64_C(0xffff62947fffffff));
      arg2 = vcreate_s16(UINT64_C(0x7fff7fff388bffff));
      clear_neon_saturated();
      //  Expect: "result" = ffffe293b88afffe
      result = vsqadd_u16(arg1, arg2);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u16(result), 0);
      exp = UINT64_C(0xffffe293b88afffe);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_93() {

{
   {
      uint32x2_t arg1;
      int32x2_t arg2;
      uint32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"saturating_add\", fnname = \"vsqadd_u32\", rettype = \"uint32x2_t\", argtypes = \"[uint32x2_t,int32x2_t]\", vals = [VectorVal [IntegerVal 2147549183,IntegerVal 0],VectorVal [IntegerVal 65535,IntegerVal 65535]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u32(UINT64_C(0x000000008000ffff));
      arg2 = vcreate_s32(UINT64_C(0x0000ffff0000ffff));
      clear_neon_saturated();
      //  Expect: "result" = 0000ffff8001fffe
      result = vsqadd_u32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u32(result), 0);
      exp = UINT64_C(0x0000ffff8001fffe);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_94() {

{
   {
      uint64x1_t arg1;
      int64x1_t arg2;
      uint64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"saturating_add\", fnname = \"vsqadd_u64\", rettype = \"uint64x1_t\", argtypes = \"[uint64x1_t,int64x1_t]\", vals = [VectorVal [IntegerVal 4014818332459892735],VectorVal [IntegerVal (-9223372034707324928)]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u64(UINT64_C(0x37b780007fff7fff));
      arg2 = vcreate_s64(UINT64_C(0x800000007fff8000));
      clear_neon_saturated();
      //  Expect: "result" = 0000000000000000
      result = vsqadd_u64(arg1, arg2);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      got = vget_lane_u64(result, 0);
      exp = 0;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_95() {

{
   {
      int8x16_t arg1;
      uint8x16_t arg2;
      int8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"saturating_add\", fnname = \"vuqaddq_s8\", rettype = \"int8x16_t\", argtypes = \"[int8x16_t,uint8x16_t]\", vals = [VectorVal [IntegerVal (-1),IntegerVal (-128),IntegerVal (-1),IntegerVal 0,IntegerVal (-128),IntegerVal (-1),IntegerVal 0,IntegerVal 13,IntegerVal 0,IntegerVal 0,IntegerVal 111,IntegerVal 0,IntegerVal 3,IntegerVal 0,IntegerVal (-1),IntegerVal (-128)],VectorVal [IntegerVal 0,IntegerVal 19,IntegerVal 167,IntegerVal 127,IntegerVal 0,IntegerVal 127,IntegerVal 128,IntegerVal 128,IntegerVal 248,IntegerVal 0,IntegerVal 128,IntegerVal 0,IntegerVal 0,IntegerVal 0,IntegerVal 153,IntegerVal 127]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s8(vcreate_s8(UINT64_C(0x0d00ff8000ff80ff)),
                         vcreate_s8(UINT64_C(0x80ff0003006f0000)));
      arg2 = vcombine_u8(vcreate_u8(UINT64_C(0x80807f007fa71300)),
                         vcreate_u8(UINT64_C(0x7f990000008000f8)));
      clear_neon_saturated();
      //  Expect: "result" = ff7f0003007f007f7f7f7e807f7f93ff
      result = vuqaddq_s8(arg1, arg2);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result), 0);
         exp = UINT64_C(0x7f7f7e807f7f93ff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result), 1);
         exp = UINT64_C(0xff7f0003007f007f);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_96() {

{
   {
      int16x8_t arg1;
      uint16x8_t arg2;
      int16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"saturating_add\", fnname = \"vuqaddq_s16\", rettype = \"int16x8_t\", argtypes = \"[int16x8_t,uint16x8_t]\", vals = [VectorVal [IntegerVal (-1199),IntegerVal 0,IntegerVal (-1),IntegerVal 3903,IntegerVal (-1),IntegerVal (-25457),IntegerVal 32767,IntegerVal (-32768)],VectorVal [IntegerVal 32768,IntegerVal 0,IntegerVal 32767,IntegerVal 65535,IntegerVal 32767,IntegerVal 32768,IntegerVal 65535,IntegerVal 43401]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s16(vcreate_s16(UINT64_C(0x0f3fffff0000fb51)),
                          vcreate_s16(UINT64_C(0x80007fff9c8fffff)));
      arg2 = vcombine_u16(vcreate_u16(UINT64_C(0xffff7fff00008000)),
                          vcreate_u16(UINT64_C(0xa989ffff80007fff)));
      clear_neon_saturated();
      //  Expect: "result" = 29897fff1c8f7ffe7fff7ffe00007b51
      result = vuqaddq_s16(arg1, arg2);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 0);
         exp = UINT64_C(0x7fff7ffe00007b51);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 1);
         exp = UINT64_C(0x29897fff1c8f7ffe);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_97() {

{
   {
      int32x4_t arg1;
      uint32x4_t arg2;
      int32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"saturating_add\", fnname = \"vuqaddq_s32\", rettype = \"int32x4_t\", argtypes = \"[int32x4_t,uint32x4_t]\", vals = [VectorVal [IntegerVal 32768,IntegerVal (-2147418113),IntegerVal (-32768),IntegerVal 32767],VectorVal [IntegerVal 2147549183,IntegerVal 2147418112,IntegerVal 4260102143,IntegerVal 4294934527]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s32(vcreate_s32(UINT64_C(0x8000ffff00008000)),
                          vcreate_s32(UINT64_C(0x00007fffffff8000)));
      arg2 = vcombine_u32(vcreate_u32(UINT64_C(0x7fff00008000ffff)),
                          vcreate_u32(UINT64_C(0xffff7ffffdebffff)));
      clear_neon_saturated();
      //  Expect: "result" = 7fffffff7fffffffffffffff7fffffff
      result = vuqaddq_s32(arg1, arg2);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 0);
         exp = UINT64_C(0xffffffff7fffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 1);
         exp = UINT64_C(0x7fffffff7fffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_98() {

{
   {
      int64x2_t arg1;
      uint64x2_t arg2;
      int64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"saturating_add\", fnname = \"vuqaddq_s64\", rettype = \"int64x2_t\", argtypes = \"[int64x2_t,uint64x2_t]\", vals = [VectorVal [IntegerVal 9223231297500512255,IntegerVal 9223104050222825472],VectorVal [IntegerVal 9223231301513904127,IntegerVal 140741783289856]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s64(vcreate_s64(UINT64_C(0x7fff7fff90c87fff)),
                          vcreate_s64(UINT64_C(0x7fff0c447fff8000)));
      arg2 = vcombine_u64(vcreate_u64(UINT64_C(0x7fff80007fffffff)),
                          vcreate_u64(UINT64_C(0x00008000ffff8000)));
      clear_neon_saturated();
      //  Expect: "result" = 7fff8c457fff00007fffffffffffffff
      result = vuqaddq_s64(arg1, arg2);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 0);
         exp = UINT64_C(0x7fffffffffffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 1);
         exp = UINT64_C(0x7fff8c457fff0000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_99() {

{
   {
      uint8x16_t arg1;
      int8x16_t arg2;
      uint8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"saturating_add\", fnname = \"vsqaddq_u8\", rettype = \"uint8x16_t\", argtypes = \"[uint8x16_t,int8x16_t]\", vals = [VectorVal [IntegerVal 109,IntegerVal 128,IntegerVal 127,IntegerVal 0,IntegerVal 128,IntegerVal 127,IntegerVal 127,IntegerVal 6,IntegerVal 128,IntegerVal 255,IntegerVal 255,IntegerVal 165,IntegerVal 248,IntegerVal 127,IntegerVal 0,IntegerVal 90],VectorVal [IntegerVal (-128),IntegerVal (-1),IntegerVal (-1),IntegerVal (-128),IntegerVal 94,IntegerVal (-128),IntegerVal 127,IntegerVal (-128),IntegerVal 127,IntegerVal (-128),IntegerVal (-128),IntegerVal 127,IntegerVal 127,IntegerVal 72,IntegerVal (-1),IntegerVal 113]], start_saturated = True}";
      int reported = 0;
      arg1 = vcombine_u8(vcreate_u8(UINT64_C(0x067f7f80007f806d)),
                         vcreate_u8(UINT64_C(0x5a007ff8a5ffff80)));
      arg2 = vcombine_s8(vcreate_s8(UINT64_C(0x807f805e80ffff80)),
                         vcreate_s8(UINT64_C(0x71ff487f7f80807f)));
      set_neon_saturated();
      //  Expect: "result" = cb00c7ffff7f7fff00fe00de007e7f00
      result = vsqaddq_u8(arg1, arg2);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 0);
         exp = UINT64_C(0x00fe00de007e7f00);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 1);
         exp = UINT64_C(0xcb00c7ffff7f7fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_100() {

{
   {
      uint16x8_t arg1;
      int16x8_t arg2;
      uint16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"saturating_add\", fnname = \"vsqaddq_u16\", rettype = \"uint16x8_t\", argtypes = \"[uint16x8_t,int16x8_t]\", vals = [VectorVal [IntegerVal 32768,IntegerVal 32767,IntegerVal 0,IntegerVal 65535,IntegerVal 65535,IntegerVal 65535,IntegerVal 32767,IntegerVal 0],VectorVal [IntegerVal (-1),IntegerVal 29755,IntegerVal 0,IntegerVal 32767,IntegerVal (-1),IntegerVal 32767,IntegerVal (-32768),IntegerVal (-1)]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u16(vcreate_u16(UINT64_C(0xffff00007fff8000)),
                          vcreate_u16(UINT64_C(0x00007fffffffffff)));
      arg2 = vcombine_s16(vcreate_s16(UINT64_C(0x7fff0000743bffff)),
                          vcreate_s16(UINT64_C(0xffff80007fffffff)));
      clear_neon_saturated();
      //  Expect: "result" = 00000000fffffffeffff0000f43a7fff
      result = vsqaddq_u16(arg1, arg2);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 0);
         exp = UINT64_C(0xffff0000f43a7fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 1);
         exp = UINT64_C(0x00000000fffffffe);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_101() {

{
   {
      uint32x4_t arg1;
      int32x4_t arg2;
      uint32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"saturating_add\", fnname = \"vsqaddq_u32\", rettype = \"uint32x4_t\", argtypes = \"[uint32x4_t,int32x4_t]\", vals = [VectorVal [IntegerVal 20885,IntegerVal 0,IntegerVal 32768,IntegerVal 3863216127],VectorVal [IntegerVal (-32768),IntegerVal 32767,IntegerVal (-1322287104),IntegerVal 63161]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u32(vcreate_u32(UINT64_C(0x0000000000005195)),
                          vcreate_u32(UINT64_C(0xe643ffff00008000)));
      arg2 = vcombine_s32(vcreate_s32(UINT64_C(0x00007fffffff8000)),
                          vcreate_s32(UINT64_C(0x0000f6b9b12f8000)));
      clear_neon_saturated();
      //  Expect: "result" = e644f6b80000000000007fff00000000
      result = vsqaddq_u32(arg1, arg2);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 0);
         exp = UINT64_C(0x00007fff00000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 1);
         exp = UINT64_C(0xe644f6b800000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_102() {

{
   {
      uint64x2_t arg1;
      int64x2_t arg2;
      uint64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"saturating_add\", fnname = \"vsqaddq_u64\", rettype = \"uint64x2_t\", argtypes = \"[uint64x2_t,int64x2_t]\", vals = [VectorVal [IntegerVal 5622040448772866048,IntegerVal 18446744071562035199],VectorVal [IntegerVal (-21916144074752),IntegerVal 407153555959447552]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u64(vcreate_u64(UINT64_C(0x4e05800055fc0000)),
                          vcreate_u64(UINT64_C(0xffffffff7fff7fff)));
      arg2 = vcombine_s64(vcreate_s64(UINT64_C(0xffffec1140048000)),
                          vcreate_s64(UINT64_C(0x05a6800080000000)));
      clear_neon_saturated();
      //  Expect: "result" = ffffffffffffffff4e056c1196008000
      result = vsqaddq_u64(arg1, arg2);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 0);
         exp = UINT64_C(0x4e056c1196008000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 1);
         exp = UINT64_C(0xffffffffffffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_103() {

{
   {
      int8_t arg1;
      int8_t arg2;
      int8_t result;
      char* str1 = "ReproInfo2 {semantics = \"saturating_add\", fnname = \"vqaddb_s8\", rettype = \"int8_t\", argtypes = \"[int8_t,int8_t]\", vals = [IntegerVal (-1),IntegerVal 0], start_saturated = False}";
      int reported = 0;
      int8_t got;
      int8_t exp;
      arg1 = -1;
      arg2 = 0;
      clear_neon_saturated();
      //  Expect: "result" = ff
      result = vqaddb_s8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = -1;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_104() {

{
   {
      int16_t arg1;
      int16_t arg2;
      int16_t result;
      char* str1 = "ReproInfo2 {semantics = \"saturating_add\", fnname = \"vqaddh_s16\", rettype = \"int16_t\", argtypes = \"[int16_t,int16_t]\", vals = [IntegerVal 21762,IntegerVal 0], start_saturated = False}";
      int reported = 0;
      int16_t got;
      int16_t exp;
      arg1 = 21762;
      arg2 = 0;
      clear_neon_saturated();
      //  Expect: "result" = 5502
      result = vqaddh_s16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = 21762;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIi16 " Got: %" PRIi16 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_105() {

{
   {
      int32_t arg1;
      int32_t arg2;
      int32_t result;
      char* str1 = "ReproInfo2 {semantics = \"saturating_add\", fnname = \"vqadds_s32\", rettype = \"int32_t\", argtypes = \"[int32_t,int32_t]\", vals = [IntegerVal 0,IntegerVal 2147450880], start_saturated = False}";
      int reported = 0;
      int32_t got;
      int32_t exp;
      arg1 = 0;
      arg2 = 2147450880;
      clear_neon_saturated();
      //  Expect: "result" = 7fff8000
      result = vqadds_s32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = 2147450880;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIi32 " Got: %" PRIi32 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_106() {

{
   {
      int64_t arg1;
      int64_t arg2;
      int64_t result;
      char* str1 = "ReproInfo2 {semantics = \"saturating_add\", fnname = \"vqaddd_s64\", rettype = \"int64_t\", argtypes = \"[int64_t,int64_t]\", vals = [IntegerVal 140733193453567,IntegerVal (-9223185811367758745)], start_saturated = False}";
      int reported = 0;
      int64_t got;
      int64_t exp;
      arg1 = INT64_C(140733193453567);
      arg2 = INT64_C(-9223185811367758745);
      clear_neon_saturated();
      //  Expect: "result" = 8001295e00017466
      result = vqaddd_s64(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = INT64_C(-9223045078174305178);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIi64 " Got: %" PRIi64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_107() {

{
   {
      uint8_t arg1;
      uint8_t arg2;
      uint8_t result;
      char* str1 = "ReproInfo2 {semantics = \"saturating_add\", fnname = \"vqaddb_u8\", rettype = \"uint8_t\", argtypes = \"[uint8_t,uint8_t]\", vals = [IntegerVal 0,IntegerVal 128], start_saturated = False}";
      int reported = 0;
      uint8_t got;
      uint8_t exp;
      arg1 = 0;
      arg2 = 128U;
      clear_neon_saturated();
      //  Expect: "result" = 80
      result = vqaddb_u8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = 128U;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_108() {

{
   {
      uint16_t arg1;
      uint16_t arg2;
      uint16_t result;
      char* str1 = "ReproInfo2 {semantics = \"saturating_add\", fnname = \"vqaddh_u16\", rettype = \"uint16_t\", argtypes = \"[uint16_t,uint16_t]\", vals = [IntegerVal 0,IntegerVal 65535], start_saturated = False}";
      int reported = 0;
      uint16_t got;
      uint16_t exp;
      arg1 = 0;
      arg2 = 65535U;
      clear_neon_saturated();
      //  Expect: "result" = ffff
      result = vqaddh_u16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = 65535U;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_109() {

{
   {
      uint32_t arg1;
      uint32_t arg2;
      uint32_t result;
      char* str1 = "ReproInfo2 {semantics = \"saturating_add\", fnname = \"vqadds_u32\", rettype = \"uint32_t\", argtypes = \"[uint32_t,uint32_t]\", vals = [IntegerVal 2147483647,IntegerVal 2147483647], start_saturated = False}";
      int reported = 0;
      uint32_t got;
      uint32_t exp;
      arg1 = 2147483647U;
      arg2 = 2147483647U;
      clear_neon_saturated();
      //  Expect: "result" = fffffffe
      result = vqadds_u32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = 4294967294U;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIu32 " Got: %" PRIu32 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_110() {

{
   {
      uint64_t arg1;
      uint64_t arg2;
      uint64_t result;
      char* str1 = "ReproInfo2 {semantics = \"saturating_add\", fnname = \"vqaddd_u64\", rettype = \"uint64_t\", argtypes = \"[uint64_t,uint64_t]\", vals = [IntegerVal 9223621658206502912,IntegerVal 4870361519876964352], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = UINT64_C(0x8000e3077fff8000);
      arg2 = UINT64_C(0x4396ffff7fff8000);
      clear_neon_saturated();
      //  Expect: "result" = c397e306ffff0000
      result = vqaddd_u64(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = UINT64_C(0xc397e306ffff0000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_111() {

{
   {
      int8_t arg1;
      uint8_t arg2;
      int8_t result;
      char* str1 = "ReproInfo2 {semantics = \"saturating_add\", fnname = \"vuqaddb_s8\", rettype = \"int8_t\", argtypes = \"[int8_t,uint8_t]\", vals = [IntegerVal (-1),IntegerVal 255], start_saturated = False}";
      int reported = 0;
      int8_t got;
      int8_t exp;
      arg1 = -1;
      arg2 = 255U;
      clear_neon_saturated();
      //  Expect: "result" = 7f
      result = vuqaddb_s8(arg1, arg2);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      got = result;
      exp = 127;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_112() {

{
   {
      int16_t arg1;
      uint16_t arg2;
      int16_t result;
      char* str1 = "ReproInfo2 {semantics = \"saturating_add\", fnname = \"vuqaddh_s16\", rettype = \"int16_t\", argtypes = \"[int16_t,uint16_t]\", vals = [IntegerVal 3233,IntegerVal 0], start_saturated = False}";
      int reported = 0;
      int16_t got;
      int16_t exp;
      arg1 = 3233;
      arg2 = 0;
      clear_neon_saturated();
      //  Expect: "result" = 0ca1
      result = vuqaddh_s16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = 3233;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIi16 " Got: %" PRIi16 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_113() {

{
   {
      int32_t arg1;
      uint32_t arg2;
      int32_t result;
      char* str1 = "ReproInfo2 {semantics = \"saturating_add\", fnname = \"vuqadds_s32\", rettype = \"int32_t\", argtypes = \"[int32_t,uint32_t]\", vals = [IntegerVal (-32769),IntegerVal 35712], start_saturated = False}";
      int reported = 0;
      int32_t got;
      int32_t exp;
      arg1 = -32769;
      arg2 = 35712U;
      clear_neon_saturated();
      //  Expect: "result" = 00000b7f
      result = vuqadds_s32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = 2943;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIi32 " Got: %" PRIi32 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_114() {

{
   {
      int64_t arg1;
      uint64_t arg2;
      int64_t result;
      char* str1 = "ReproInfo2 {semantics = \"saturating_add\", fnname = \"vuqaddd_s64\", rettype = \"int64_t\", argtypes = \"[int64_t,uint64_t]\", vals = [IntegerVal 35747324189736960,IntegerVal 9223231297218969599], start_saturated = False}";
      int reported = 0;
      int64_t got;
      int64_t exp;
      arg1 = INT64_C(35747324189736960);
      arg2 = UINT64_C(0x7fff7fff80007fff);
      clear_neon_saturated();
      //  Expect: "result" = 7fffffffffffffff
      result = vuqaddd_s64(arg1, arg2);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      got = result;
      exp = INT64_C(9223372036854775807);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIi64 " Got: %" PRIi64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_115() {

{
   {
      uint8_t arg1;
      int8_t arg2;
      uint8_t result;
      char* str1 = "ReproInfo2 {semantics = \"saturating_add\", fnname = \"vsqaddb_u8\", rettype = \"uint8_t\", argtypes = \"[uint8_t,int8_t]\", vals = [IntegerVal 127,IntegerVal (-128)], start_saturated = False}";
      int reported = 0;
      uint8_t got;
      uint8_t exp;
      arg1 = 127U;
      arg2 = -128;
      clear_neon_saturated();
      //  Expect: "result" = 00
      result = vsqaddb_u8(arg1, arg2);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      got = result;
      exp = 0;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_116() {

{
   {
      uint16_t arg1;
      int16_t arg2;
      uint16_t result;
      char* str1 = "ReproInfo2 {semantics = \"saturating_add\", fnname = \"vsqaddh_u16\", rettype = \"uint16_t\", argtypes = \"[uint16_t,int16_t]\", vals = [IntegerVal 65535,IntegerVal (-16357)], start_saturated = False}";
      int reported = 0;
      uint16_t got;
      uint16_t exp;
      arg1 = 65535U;
      arg2 = -16357;
      clear_neon_saturated();
      //  Expect: "result" = c01a
      result = vsqaddh_u16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = 49178U;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_117() {

{
   {
      uint32_t arg1;
      int32_t arg2;
      uint32_t result;
      char* str1 = "ReproInfo2 {semantics = \"saturating_add\", fnname = \"vsqadds_u32\", rettype = \"uint32_t\", argtypes = \"[uint32_t,int32_t]\", vals = [IntegerVal 2147549183,IntegerVal (-2147450881)], start_saturated = False}";
      int reported = 0;
      uint32_t got;
      uint32_t exp;
      arg1 = 2147549183U;
      arg2 = -2147450881;
      clear_neon_saturated();
      //  Expect: "result" = 00017ffe
      result = vsqadds_u32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = 98302U;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIu32 " Got: %" PRIu32 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_118() {

{
   {
      uint64_t arg1;
      int64_t arg2;
      uint64_t result;
      char* str1 = "ReproInfo2 {semantics = \"saturating_add\", fnname = \"vsqaddd_u64\", rettype = \"uint64_t\", argtypes = \"[uint64_t,int64_t]\", vals = [IntegerVal 9223231299366450211,IntegerVal 281470681743360], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = UINT64_C(0x7fff800000007423);
      arg2 = INT64_C(281470681743360);
      clear_neon_saturated();
      //  Expect: "result" = 80007fff00007423
      result = vsqaddd_u64(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = UINT64_C(0x80007fff00007423);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_119() {

{
   {
      int16x8_t arg1;
      int16x8_t arg2;
      int8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"highhalf_add\", fnname = \"vaddhn_s16\", rettype = \"int8x8_t\", argtypes = \"[int16x8_t,int16x8_t]\", vals = [VectorVal [IntegerVal 32767,IntegerVal 0,IntegerVal (-32768),IntegerVal 32767,IntegerVal 12886,IntegerVal 0,IntegerVal 0,IntegerVal 32767],VectorVal [IntegerVal 0,IntegerVal 32122,IntegerVal (-32768),IntegerVal 0,IntegerVal (-1),IntegerVal (-32768),IntegerVal 0,IntegerVal 32767]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcombine_s16(vcreate_s16(UINT64_C(0x7fff800000007fff)),
                          vcreate_s16(UINT64_C(0x7fff000000003256)));
      arg2 = vcombine_s16(vcreate_s16(UINT64_C(0x000080007d7a0000)),
                          vcreate_s16(UINT64_C(0x7fff00008000ffff)));
      clear_neon_saturated();
      //  Expect: "result" = ff0080327f007d7f
      result = vaddhn_s16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s8(result), 0);
      exp = UINT64_C(0xff0080327f007d7f);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_120() {

{
   {
      int32x4_t arg1;
      int32x4_t arg2;
      int16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"highhalf_add\", fnname = \"vaddhn_s32\", rettype = \"int16x4_t\", argtypes = \"[int32x4_t,int32x4_t]\", vals = [VectorVal [IntegerVal 1509490688,IntegerVal (-2147450880),IntegerVal (-2147450881),IntegerVal (-2085276856)],VectorVal [IntegerVal 32767,IntegerVal (-32769),IntegerVal 2147483647,IntegerVal (-32768)]], start_saturated = True}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcombine_s32(vcreate_s32(UINT64_C(0x8000800059f90000)),
                          vcreate_s32(UINT64_C(0x83b5334880007fff)));
      arg2 = vcombine_s32(vcreate_s32(UINT64_C(0xffff7fff00007fff)),
                          vcreate_s32(UINT64_C(0xffff80007fffffff)));
      set_neon_saturated();
      //  Expect: "result" = 83b400007fff59f9
      result = vaddhn_s32(arg1, arg2);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s16(result), 0);
      exp = UINT64_C(0x83b400007fff59f9);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_121() {

{
   {
      int64x2_t arg1;
      int64x2_t arg2;
      int32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"highhalf_add\", fnname = \"vaddhn_s64\", rettype = \"int32x2_t\", argtypes = \"[int64x2_t,int64x2_t]\", vals = [VectorVal [IntegerVal (-9223372036854710273),IntegerVal (-140739635838977)],VectorVal [IntegerVal 140741783289856,IntegerVal 8485344647919384359]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcombine_s64(vcreate_s64(UINT64_C(0x800000000000ffff)),
                          vcreate_s64(UINT64_C(0xffff7fff7fffffff)));
      arg2 = vcombine_s64(vcreate_s64(UINT64_C(0x00008000ffff8000)),
                          vcreate_s64(UINT64_C(0x75c1ffffffff3727)));
      clear_neon_saturated();
      //  Expect: "result" = 75c17fff80008001
      result = vaddhn_s64(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s32(result), 0);
      exp = UINT64_C(0x75c17fff80008001);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_122() {

{
   {
      uint16x8_t arg1;
      uint16x8_t arg2;
      uint8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"highhalf_add\", fnname = \"vaddhn_u16\", rettype = \"uint8x8_t\", argtypes = \"[uint16x8_t,uint16x8_t]\", vals = [VectorVal [IntegerVal 0,IntegerVal 32768,IntegerVal 32767,IntegerVal 32767,IntegerVal 0,IntegerVal 0,IntegerVal 32767,IntegerVal 65535],VectorVal [IntegerVal 21696,IntegerVal 13171,IntegerVal 32768,IntegerVal 65535,IntegerVal 17610,IntegerVal 0,IntegerVal 0,IntegerVal 32767]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcombine_u16(vcreate_u16(UINT64_C(0x7fff7fff80000000)),
                          vcreate_u16(UINT64_C(0xffff7fff00000000)));
      arg2 = vcombine_u16(vcreate_u16(UINT64_C(0xffff8000337354c0)),
                          vcreate_u16(UINT64_C(0x7fff0000000044ca)));
      clear_neon_saturated();
      //  Expect: "result" = 7f7f00447fffb354
      result = vaddhn_u16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u8(result), 0);
      exp = UINT64_C(0x7f7f00447fffb354);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_123() {

{
   {
      uint32x4_t arg1;
      uint32x4_t arg2;
      uint16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"highhalf_add\", fnname = \"vaddhn_u32\", rettype = \"uint16x4_t\", argtypes = \"[uint32x4_t,uint32x4_t]\", vals = [VectorVal [IntegerVal 2147483647,IntegerVal 1889926006,IntegerVal 2147450879,IntegerVal 2147516416],VectorVal [IntegerVal 2147516416,IntegerVal 36423,IntegerVal 616497151,IntegerVal 4294927391]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcombine_u32(vcreate_u32(UINT64_C(0x70a5fb767fffffff)),
                          vcreate_u32(UINT64_C(0x800080007fff7fff)));
      arg2 = vcombine_u32(vcreate_u32(UINT64_C(0x00008e4780008000)),
                          vcreate_u32(UINT64_C(0xffff641f24beffff)));
      clear_neon_saturated();
      //  Expect: "result" = 7fffa4be70a60000
      result = vaddhn_u32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u16(result), 0);
      exp = UINT64_C(0x7fffa4be70a60000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_124() {

{
   {
      uint64x2_t arg1;
      uint64x2_t arg2;
      uint32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"highhalf_add\", fnname = \"vaddhn_u64\", rettype = \"uint32x2_t\", argtypes = \"[uint64x2_t,uint64x2_t]\", vals = [VectorVal [IntegerVal 9223512772195647487,IntegerVal 140735340871679],VectorVal [IntegerVal 2147450880,IntegerVal 9223090562789169855]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcombine_u64(vcreate_u64(UINT64_C(0x80007fff7fffffff)),
                          vcreate_u64(UINT64_C(0x00007fff7fffffff)));
      arg2 = vcombine_u64(vcreate_u64(UINT64_C(0x000000007fff8000)),
                          vcreate_u64(UINT64_C(0x7fff0000364e5abf)));
      clear_neon_saturated();
      //  Expect: "result" = 7fff7fff80007fff
      result = vaddhn_u64(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u32(result), 0);
      exp = UINT64_C(0x7fff7fff80007fff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_125() {

{
   {
      int8x8_t arg1;
      int16x8_t arg2;
      int16x8_t arg3;
      int8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"highhalf_add\", fnname = \"vaddhn_high_s16\", rettype = \"int8x16_t\", argtypes = \"[int8x8_t,int16x8_t,int16x8_t]\", vals = [VectorVal [IntegerVal 70,IntegerVal 127,IntegerVal (-128),IntegerVal 127,IntegerVal (-128),IntegerVal (-128),IntegerVal 127,IntegerVal (-1)],VectorVal [IntegerVal 8588,IntegerVal 0,IntegerVal (-1),IntegerVal (-32768),IntegerVal (-32768),IntegerVal (-1),IntegerVal 0,IntegerVal (-32768)],VectorVal [IntegerVal 0,IntegerVal 32767,IntegerVal 0,IntegerVal (-32768),IntegerVal 32767,IntegerVal 0,IntegerVal 0,IntegerVal (-32768)]], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_s8(UINT64_C(0xff7f80807f807f46));
      arg2 = vcombine_s16(vcreate_s16(UINT64_C(0x8000ffff0000218c)),
                          vcreate_s16(UINT64_C(0x80000000ffff8000)));
      arg3 = vcombine_s16(vcreate_s16(UINT64_C(0x800000007fff0000)),
                          vcreate_s16(UINT64_C(0x8000000000007fff)));
      clear_neon_saturated();
      //  Expect: "result" = 0000ffff00ff7f21ff7f80807f807f46
      result = vaddhn_high_s16(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result), 0);
         exp = UINT64_C(0xff7f80807f807f46);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result), 1);
         exp = UINT64_C(0x0000ffff00ff7f21);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_126() {

{
   {
      int16x4_t arg1;
      int32x4_t arg2;
      int32x4_t arg3;
      int16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"highhalf_add\", fnname = \"vaddhn_high_s32\", rettype = \"int16x8_t\", argtypes = \"[int16x4_t,int32x4_t,int32x4_t]\", vals = [VectorVal [IntegerVal (-23535),IntegerVal (-32768),IntegerVal 32767,IntegerVal (-32768)],VectorVal [IntegerVal 32768,IntegerVal (-2147470210),IntegerVal (-81362944),IntegerVal (-125)],VectorVal [IntegerVal 32768,IntegerVal (-32769),IntegerVal 2147465160,IntegerVal 2147483647]], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_s16(UINT64_C(0x80007fff8000a411));
      arg2 = vcombine_s32(vcreate_s32(UINT64_C(0x8000347e00008000)),
                          vcreate_s32(UINT64_C(0xffffff83fb268000)));
      arg3 = vcombine_s32(vcreate_s32(UINT64_C(0xffff7fff00008000)),
                          vcreate_s32(UINT64_C(0x7fffffff7fffb7c8)));
      clear_neon_saturated();
      //  Expect: "result" = 7fff7b267fff000180007fff8000a411
      result = vaddhn_high_s32(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 0);
         exp = UINT64_C(0x80007fff8000a411);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 1);
         exp = UINT64_C(0x7fff7b267fff0001);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_127() {

{
   {
      int32x2_t arg1;
      int64x2_t arg2;
      int64x2_t arg3;
      int32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"highhalf_add\", fnname = \"vaddhn_high_s64\", rettype = \"int32x4_t\", argtypes = \"[int32x2_t,int64x2_t,int64x2_t]\", vals = [VectorVal [IntegerVal (-1789624321),IntegerVal (-1)],VectorVal [IntegerVal 9223369406187307008,IntegerVal 140739635838975],VectorVal [IntegerVal 96439195664383,IntegerVal 9223372035172630527]], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_s32(UINT64_C(0xffffffff95547fff));
      arg2 = vcombine_s64(vcreate_s64(UINT64_C(0x7ffffd9b80000000)),
                          vcreate_s64(UINT64_C(0x000080007fffffff)));
      arg3 = vcombine_s64(vcreate_s64(UINT64_C(0x000057b5ffffffff)),
                          vcreate_s64(UINT64_C(0x7fffffff9bbc7fff)));
      clear_neon_saturated();
      //  Expect: "result" = 8000800080005551ffffffff95547fff
      result = vaddhn_high_s64(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 0);
         exp = UINT64_C(0xffffffff95547fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 1);
         exp = UINT64_C(0x8000800080005551);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_128() {

{
   {
      uint8x8_t arg1;
      uint16x8_t arg2;
      uint16x8_t arg3;
      uint8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"highhalf_add\", fnname = \"vaddhn_high_u16\", rettype = \"uint8x16_t\", argtypes = \"[uint8x8_t,uint16x8_t,uint16x8_t]\", vals = [VectorVal [IntegerVal 0,IntegerVal 127,IntegerVal 127,IntegerVal 128,IntegerVal 0,IntegerVal 128,IntegerVal 128,IntegerVal 0],VectorVal [IntegerVal 65535,IntegerVal 4791,IntegerVal 32767,IntegerVal 32767,IntegerVal 7251,IntegerVal 65535,IntegerVal 32768,IntegerVal 32767],VectorVal [IntegerVal 0,IntegerVal 32767,IntegerVal 5390,IntegerVal 32768,IntegerVal 32768,IntegerVal 65159,IntegerVal 65535,IntegerVal 32768]], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_u8(UINT64_C(0x00808000807f7f00));
      arg2 = vcombine_u16(vcreate_u16(UINT64_C(0x7fff7fff12b7ffff)),
                          vcreate_u16(UINT64_C(0x7fff8000ffff1c53)));
      arg3 = vcombine_u16(vcreate_u16(UINT64_C(0x8000150e7fff0000)),
                          vcreate_u16(UINT64_C(0x8000fffffe878000)));
      clear_neon_saturated();
      //  Expect: "result" = ff7ffe9cff9592ff00808000807f7f00
      result = vaddhn_high_u16(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 0);
         exp = UINT64_C(0x00808000807f7f00);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 1);
         exp = UINT64_C(0xff7ffe9cff9592ff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_129() {

{
   {
      uint16x4_t arg1;
      uint32x4_t arg2;
      uint32x4_t arg3;
      uint16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"highhalf_add\", fnname = \"vaddhn_high_u32\", rettype = \"uint16x8_t\", argtypes = \"[uint16x4_t,uint32x4_t,uint32x4_t]\", vals = [VectorVal [IntegerVal 32768,IntegerVal 9660,IntegerVal 32768,IntegerVal 65535],VectorVal [IntegerVal 2147483648,IntegerVal 2147418112,IntegerVal 3761505964,IntegerVal 4294934527],VectorVal [IntegerVal 32767,IntegerVal 0,IntegerVal 2147516416,IntegerVal 4294967295]], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_u16(UINT64_C(0xffff800025bc8000));
      arg2 = vcombine_u32(vcreate_u32(UINT64_C(0x7fff000080000000)),
                          vcreate_u32(UINT64_C(0xffff7fffe03406ac)));
      arg3 = vcombine_u32(vcreate_u32(UINT64_C(0x0000000000007fff)),
                          vcreate_u32(UINT64_C(0xffffffff80008000)));
      clear_neon_saturated();
      //  Expect: "result" = ffff60347fff8000ffff800025bc8000
      result = vaddhn_high_u32(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 0);
         exp = UINT64_C(0xffff800025bc8000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 1);
         exp = UINT64_C(0xffff60347fff8000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_130() {

{
   {
      uint32x2_t arg1;
      uint64x2_t arg2;
      uint64x2_t arg3;
      uint32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"highhalf_add\", fnname = \"vaddhn_high_u64\", rettype = \"uint32x4_t\", argtypes = \"[uint32x2_t,uint64x2_t,uint64x2_t]\", vals = [VectorVal [IntegerVal 2279014399,IntegerVal 1265958912],VectorVal [IntegerVal 9223512772195591529,IntegerVal 9223372039002324991],VectorVal [IntegerVal 140733193388032,IntegerVal 9223231299038838784]], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_u32(UINT64_C(0x4b75000087d6ffff));
      arg2 = vcombine_u64(vcreate_u64(UINT64_C(0x80007fff7fff2569)),
                          vcreate_u64(UINT64_C(0x800000008000ffff)));
      arg3 = vcombine_u64(vcreate_u64(UINT64_C(0x00007fff00000000)),
                          vcreate_u64(UINT64_C(0x7fff7fffec798000)));
      clear_neon_saturated();
      //  Expect: "result" = ffff80008000fffe4b75000087d6ffff
      result = vaddhn_high_u64(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 0);
         exp = UINT64_C(0x4b75000087d6ffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 1);
         exp = UINT64_C(0xffff80008000fffe);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_131() {

{
   {
      int16x8_t arg1;
      int16x8_t arg2;
      int8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"roundinghighhalf_add\", fnname = \"vraddhn_s16\", rettype = \"int8x8_t\", argtypes = \"[int16x8_t,int16x8_t]\", vals = [VectorVal [IntegerVal (-1),IntegerVal 0,IntegerVal 22176,IntegerVal (-1),IntegerVal (-1),IntegerVal 0,IntegerVal (-32768),IntegerVal 0],VectorVal [IntegerVal (-32768),IntegerVal 32767,IntegerVal 1071,IntegerVal (-32768),IntegerVal (-1),IntegerVal 11782,IntegerVal 32767,IntegerVal (-32768)]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcombine_s16(vcreate_s16(UINT64_C(0xffff56a00000ffff)),
                          vcreate_s16(UINT64_C(0x000080000000ffff)));
      arg2 = vcombine_s16(vcreate_s16(UINT64_C(0x8000042f7fff8000)),
                          vcreate_s16(UINT64_C(0x80007fff2e06ffff)));
      clear_neon_saturated();
      //  Expect: "result" = 80002e00805b8080
      result = vraddhn_s16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s8(result), 0);
      exp = UINT64_C(0x80002e00805b8080);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_132() {

{
   {
      int32x4_t arg1;
      int32x4_t arg2;
      int16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"roundinghighhalf_add\", fnname = \"vraddhn_s32\", rettype = \"int16x4_t\", argtypes = \"[int32x4_t,int32x4_t]\", vals = [VectorVal [IntegerVal 358350847,IntegerVal (-2147483648),IntegerVal 32767,IntegerVal 2147450879],VectorVal [IntegerVal 32768,IntegerVal 32767,IntegerVal 762118144,IntegerVal (-2147418113)]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcombine_s32(vcreate_s32(UINT64_C(0x80000000155bffff)),
                          vcreate_s32(UINT64_C(0x7fff7fff00007fff)));
      arg2 = vcombine_s32(vcreate_s32(UINT64_C(0x00007fff00008000)),
                          vcreate_s32(UINT64_C(0x8000ffff2d6d0000)));
      clear_neon_saturated();
      //  Expect: "result" = 00002d6d8000155c
      result = vraddhn_s32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s16(result), 0);
      exp = UINT64_C(0x00002d6d8000155c);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_133() {

{
   {
      int64x2_t arg1;
      int64x2_t arg2;
      int32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"roundinghighhalf_add\", fnname = \"vraddhn_s64\", rettype = \"int32x2_t\", argtypes = \"[int64x2_t,int64x2_t]\", vals = [VectorVal [IntegerVal (-9223090564025580056),IntegerVal 9223256639673466879],VectorVal [IntegerVal 9223372036527962365,IntegerVal (-5590655985279533057)]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcombine_s64(vcreate_s64(UINT64_C(0x8000ffff7fff85e8)),
                          vcreate_s64(UINT64_C(0x7fff970bffffffff)));
      arg2 = vcombine_s64(vcreate_s64(UINT64_C(0x7fffffffec8538fd)),
                          vcreate_s64(UINT64_C(0xb26a000080007fff)));
      clear_neon_saturated();
      //  Expect: "result" = 3269970d0000ffff
      result = vraddhn_s64(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s32(result), 0);
      exp = UINT64_C(0x3269970d0000ffff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_134() {

{
   {
      uint16x8_t arg1;
      uint16x8_t arg2;
      uint8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"roundinghighhalf_add\", fnname = \"vraddhn_u16\", rettype = \"uint8x8_t\", argtypes = \"[uint16x8_t,uint16x8_t]\", vals = [VectorVal [IntegerVal 32768,IntegerVal 32768,IntegerVal 0,IntegerVal 0,IntegerVal 4248,IntegerVal 65535,IntegerVal 65535,IntegerVal 0],VectorVal [IntegerVal 0,IntegerVal 32768,IntegerVal 32767,IntegerVal 65535,IntegerVal 32767,IntegerVal 32768,IntegerVal 18784,IntegerVal 0]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcombine_u16(vcreate_u16(UINT64_C(0x0000000080008000)),
                          vcreate_u16(UINT64_C(0x0000ffffffff1098)));
      arg2 = vcombine_u16(vcreate_u16(UINT64_C(0xffff7fff80000000)),
                          vcreate_u16(UINT64_C(0x0000496080007fff)));
      clear_neon_saturated();
      //  Expect: "result" = 0049809100800080
      result = vraddhn_u16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u8(result), 0);
      exp = UINT64_C(0x0049809100800080);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_135() {

{
   {
      uint32x4_t arg1;
      uint32x4_t arg2;
      uint16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"roundinghighhalf_add\", fnname = \"vraddhn_u32\", rettype = \"uint16x4_t\", argtypes = \"[uint32x4_t,uint32x4_t]\", vals = [VectorVal [IntegerVal 2147450879,IntegerVal 32767,IntegerVal 4294934527,IntegerVal 1342603264],VectorVal [IntegerVal 4294934527,IntegerVal 54689791,IntegerVal 1666646016,IntegerVal 2147516416]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcombine_u32(vcreate_u32(UINT64_C(0x00007fff7fff7fff)),
                          vcreate_u32(UINT64_C(0x50068000ffff7fff)));
      arg2 = vcombine_u32(vcreate_u32(UINT64_C(0x03427fffffff7fff)),
                          vcreate_u32(UINT64_C(0x8000800063570000)));
      clear_neon_saturated();
      //  Expect: "result" = d007635603437fff
      result = vraddhn_u32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u16(result), 0);
      exp = UINT64_C(0xd007635603437fff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_136() {

{
   {
      uint64x2_t arg1;
      uint64x2_t arg2;
      uint32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"roundinghighhalf_add\", fnname = \"vraddhn_u64\", rettype = \"uint32x2_t\", argtypes = \"[uint64x2_t,uint64x2_t]\", vals = [VectorVal [IntegerVal 9223354979392126976,IntegerVal 9223512774343196671],VectorVal [IntegerVal 18446603334073696896,IntegerVal 9223231297218904064]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcombine_u64(vcreate_u64(UINT64_C(0x7ffff07c7fff8000)),
                          vcreate_u64(UINT64_C(0x800080000000ffff)));
      arg2 = vcombine_u64(vcreate_u64(UINT64_C(0xffff7fff7fffc280)),
                          vcreate_u64(UINT64_C(0x7fff7fff7fff8000)));
      clear_neon_saturated();
      //  Expect: "result" = 000000007fff707c
      result = vraddhn_u64(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u32(result), 0);
      exp = UINT64_C(0x000000007fff707c);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_137() {

{
   {
      int8x8_t arg1;
      int16x8_t arg2;
      int16x8_t arg3;
      int8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"roundinghighhalf_add\", fnname = \"vraddhn_high_s16\", rettype = \"int8x16_t\", argtypes = \"[int8x8_t,int16x8_t,int16x8_t]\", vals = [VectorVal [IntegerVal 28,IntegerVal (-1),IntegerVal 0,IntegerVal (-1),IntegerVal 127,IntegerVal 127,IntegerVal 87,IntegerVal (-1)],VectorVal [IntegerVal (-1),IntegerVal (-19030),IntegerVal 32767,IntegerVal (-1),IntegerVal (-32768),IntegerVal (-1),IntegerVal 10190,IntegerVal 32767],VectorVal [IntegerVal 32767,IntegerVal 0,IntegerVal (-32768),IntegerVal 32767,IntegerVal (-32768),IntegerVal 17186,IntegerVal (-32768),IntegerVal (-32768)]], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_s8(UINT64_C(0xff577f7fff00ff1c));
      arg2 = vcombine_s16(vcreate_s16(UINT64_C(0xffff7fffb5aaffff)),
                          vcreate_s16(UINT64_C(0x7fff27ceffff8000)));
      arg3 = vcombine_s16(vcreate_s16(UINT64_C(0x7fff800000007fff)),
                          vcreate_s16(UINT64_C(0x8000800043228000)));
      clear_neon_saturated();
      //  Expect: "result" = 00a843008000b680ff577f7fff00ff1c
      result = vraddhn_high_s16(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result), 0);
         exp = UINT64_C(0xff577f7fff00ff1c);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result), 1);
         exp = UINT64_C(0x00a843008000b680);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_138() {

{
   {
      int16x4_t arg1;
      int32x4_t arg2;
      int32x4_t arg3;
      int16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"roundinghighhalf_add\", fnname = \"vraddhn_high_s32\", rettype = \"int16x8_t\", argtypes = \"[int16x4_t,int32x4_t,int32x4_t]\", vals = [VectorVal [IntegerVal (-1),IntegerVal (-14242),IntegerVal (-1),IntegerVal (-32768)],VectorVal [IntegerVal (-966404798),IntegerVal (-32768),IntegerVal 1096351744,IntegerVal (-2147450881)],VectorVal [IntegerVal (-14441),IntegerVal (-2147450881),IntegerVal (-32768),IntegerVal 1372356608]], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_s16(UINT64_C(0x8000ffffc85effff));
      arg2 = vcombine_s32(vcreate_s32(UINT64_C(0xffff8000c665d542)),
                          vcreate_s32(UINT64_C(0x80007fff41590000)));
      arg3 = vcombine_s32(vcreate_s32(UINT64_C(0x80007fffffffc797)),
                          vcreate_s32(UINT64_C(0x51cc8000ffff8000)));
      clear_neon_saturated();
      //  Expect: "result" = d1cd41598000c6668000ffffc85effff
      result = vraddhn_high_s32(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 0);
         exp = UINT64_C(0x8000ffffc85effff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 1);
         exp = UINT64_C(0xd1cd41598000c666);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_139() {

{
   {
      int32x2_t arg1;
      int64x2_t arg2;
      int64x2_t arg3;
      int32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"roundinghighhalf_add\", fnname = \"vraddhn_high_s64\", rettype = \"int32x4_t\", argtypes = \"[int32x2_t,int64x2_t,int64x2_t]\", vals = [VectorVal [IntegerVal 32767,IntegerVal 35990],VectorVal [IntegerVal 9223372036854743040,IntegerVal 9223372035391873376],VectorVal [IntegerVal 5131007350458482688,IntegerVal (-140740229103617)]], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_s32(UINT64_C(0x00008c9600007fff));
      arg2 = vcombine_s64(vcreate_s64(UINT64_C(0x7fffffffffff8000)),
                          vcreate_s64(UINT64_C(0x7fffffffa8cde160)));
      arg3 = vcombine_s64(vcreate_s64(UINT64_C(0x4734ffffffff0000)),
                          vcreate_s64(UINT64_C(0xffff7fff5ca37fff)));
      clear_neon_saturated();
      //  Expect: "result" = 7fff7fffc735000000008c9600007fff
      result = vraddhn_high_s64(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 0);
         exp = UINT64_C(0x00008c9600007fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 1);
         exp = UINT64_C(0x7fff7fffc7350000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_140() {

{
   {
      uint8x8_t arg1;
      uint16x8_t arg2;
      uint16x8_t arg3;
      uint8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"roundinghighhalf_add\", fnname = \"vraddhn_high_u16\", rettype = \"uint8x16_t\", argtypes = \"[uint8x8_t,uint16x8_t,uint16x8_t]\", vals = [VectorVal [IntegerVal 0,IntegerVal 255,IntegerVal 128,IntegerVal 188,IntegerVal 0,IntegerVal 255,IntegerVal 128,IntegerVal 127],VectorVal [IntegerVal 32768,IntegerVal 32768,IntegerVal 32767,IntegerVal 32767,IntegerVal 32767,IntegerVal 0,IntegerVal 32767,IntegerVal 32768],VectorVal [IntegerVal 65535,IntegerVal 8986,IntegerVal 0,IntegerVal 0,IntegerVal 62158,IntegerVal 32767,IntegerVal 0,IntegerVal 65535]], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_u8(UINT64_C(0x7f80ff00bc80ff00));
      arg2 = vcombine_u16(vcreate_u16(UINT64_C(0x7fff7fff80008000)),
                          vcreate_u16(UINT64_C(0x80007fff00007fff)));
      arg3 = vcombine_u16(vcreate_u16(UINT64_C(0x00000000231affff)),
                          vcreate_u16(UINT64_C(0xffff00007ffff2ce)));
      clear_neon_saturated();
      //  Expect: "result" = 808080738080a3807f80ff00bc80ff00
      result = vraddhn_high_u16(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 0);
         exp = UINT64_C(0x7f80ff00bc80ff00);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 1);
         exp = UINT64_C(0x808080738080a380);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_141() {

{
   {
      uint16x4_t arg1;
      uint32x4_t arg2;
      uint32x4_t arg3;
      uint16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"roundinghighhalf_add\", fnname = \"vraddhn_high_u32\", rettype = \"uint16x8_t\", argtypes = \"[uint16x4_t,uint32x4_t,uint32x4_t]\", vals = [VectorVal [IntegerVal 32767,IntegerVal 31979,IntegerVal 65535,IntegerVal 41632],VectorVal [IntegerVal 2147532134,IntegerVal 2210966716,IntegerVal 2147432447,IntegerVal 65535],VectorVal [IntegerVal 4294934528,IntegerVal 154109705,IntegerVal 2147483648,IntegerVal 4142366720]], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_u16(UINT64_C(0xa2a0ffff7ceb7fff));
      arg2 = vcombine_u32(vcreate_u32(UINT64_C(0x83c8acbc8000bd66)),
                          vcreate_u32(UINT64_C(0x0000ffff7fff37ff)));
      arg3 = vcombine_u32(vcreate_u32(UINT64_C(0x092f8709ffff8000)),
                          vcreate_u32(UINT64_C(0xf6e7800080000000)));
      clear_neon_saturated();
      //  Expect: "result" = f6e8ffff8cf88000a2a0ffff7ceb7fff
      result = vraddhn_high_u32(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 0);
         exp = UINT64_C(0xa2a0ffff7ceb7fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 1);
         exp = UINT64_C(0xf6e8ffff8cf88000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_142() {

{
   {
      uint32x2_t arg1;
      uint64x2_t arg2;
      uint64x2_t arg3;
      uint32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"roundinghighhalf_add\", fnname = \"vraddhn_high_u64\", rettype = \"uint32x4_t\", argtypes = \"[uint32x2_t,uint64x2_t,uint64x2_t]\", vals = [VectorVal [IntegerVal 2147483647,IntegerVal 2147450879],VectorVal [IntegerVal 18446603337947906048,IntegerVal 9223231299366472468],VectorVal [IntegerVal 7884154897707335679,IntegerVal 9223512774343131136]], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_u32(UINT64_C(0x7fff7fff7fffffff));
      arg2 = vcombine_u64(vcreate_u64(UINT64_C(0xffff800066eb8000)),
                          vcreate_u64(UINT64_C(0x7fff80000000cb14)));
      arg3 = vcombine_u64(vcreate_u64(UINT64_C(0x6d6a251b80007fff)),
                          vcreate_u64(UINT64_C(0x8000800000000000)));
      clear_neon_saturated();
      //  Expect: "result" = 000000006d69a51c7fff7fff7fffffff
      result = vraddhn_high_u64(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 0);
         exp = UINT64_C(0x7fff7fff7fffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 1);
         exp = UINT64_C(0x000000006d69a51c);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_143() {

{
   {
      int8x8_t arg1;
      int8x8_t arg2;
      int8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"mul\", fnname = \"vmul_s8\", rettype = \"int8x8_t\", argtypes = \"[int8x8_t,int8x8_t]\", vals = [VectorVal [IntegerVal (-128),IntegerVal (-128),IntegerVal 0,IntegerVal (-1),IntegerVal 0,IntegerVal 0,IntegerVal (-1),IntegerVal (-86)],VectorVal [IntegerVal 0,IntegerVal (-1),IntegerVal (-128),IntegerVal (-116),IntegerVal 127,IntegerVal 127,IntegerVal (-89),IntegerVal (-128)]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s8(UINT64_C(0xaaff0000ff008080));
      arg2 = vcreate_s8(UINT64_C(0x80a77f7f8c80ff00));
      clear_neon_saturated();
      //  Expect: "result" = 0059000074008000
      result = vmul_s8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s8(result), 0);
      exp = UINT64_C(0x0059000074008000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_144() {

{
   {
      int16x4_t arg1;
      int16x4_t arg2;
      int16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"mul\", fnname = \"vmul_s16\", rettype = \"int16x4_t\", argtypes = \"[int16x4_t,int16x4_t]\", vals = [VectorVal [IntegerVal 10725,IntegerVal 32767,IntegerVal 17291,IntegerVal (-32768)],VectorVal [IntegerVal (-32768),IntegerVal (-1),IntegerVal 32767,IntegerVal (-18267)]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s16(UINT64_C(0x8000438b7fff29e5));
      arg2 = vcreate_s16(UINT64_C(0xb8a57fffffff8000));
      clear_neon_saturated();
      //  Expect: "result" = 80003c7580018000
      result = vmul_s16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s16(result), 0);
      exp = UINT64_C(0x80003c7580018000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_145() {

{
   {
      int32x2_t arg1;
      int32x2_t arg2;
      int32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"mul\", fnname = \"vmul_s32\", rettype = \"int32x2_t\", argtypes = \"[int32x2_t,int32x2_t]\", vals = [VectorVal [IntegerVal (-2147428713),IntegerVal (-2147483648)],VectorVal [IntegerVal 0,IntegerVal 2147418112]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s32(UINT64_C(0x800000008000d697));
      arg2 = vcreate_s32(UINT64_C(0x7fff000000000000));
      clear_neon_saturated();
      //  Expect: "result" = 0000000000000000
      result = vmul_s32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s32(result), 0);
      exp = 0;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_146() {

{
   {
      float32x2_t arg1;
      float32x2_t arg2;
      float32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"mul\", fnname = \"vmul_f32\", rettype = \"float32x2_t\", argtypes = \"[float32x2_t,float32x2_t]\", vals = [VectorVal [FloatVal 0.371631383895874,FloatVal 0.268302321434021],VectorVal [FloatVal 8.336490392684937e-2,FloatVal 0.9900298714637756]], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_f32(UINT64_C(0x3e895eec3ebe4678));
      arg2 = vcreate_f32(UINT64_C(0x3f7d72993daabb38));
      clear_neon_saturated();
      //  Expect: "result" = 3e88004e3cfdcbe6
      result = vmul_f32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result, 0);
         exp = ((float32_t) 3.0981015413999557e-2);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result, 1);
         exp = ((float32_t) 0.26562732458114624);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
   }
}
}
void dotests_147() {

{
   {
      uint8x8_t arg1;
      uint8x8_t arg2;
      uint8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"mul\", fnname = \"vmul_u8\", rettype = \"uint8x8_t\", argtypes = \"[uint8x8_t,uint8x8_t]\", vals = [VectorVal [IntegerVal 255,IntegerVal 127,IntegerVal 255,IntegerVal 17,IntegerVal 0,IntegerVal 218,IntegerVal 128,IntegerVal 0],VectorVal [IntegerVal 0,IntegerVal 128,IntegerVal 0,IntegerVal 199,IntegerVal 0,IntegerVal 127,IntegerVal 127,IntegerVal 127]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u8(UINT64_C(0x0080da0011ff7fff));
      arg2 = vcreate_u8(UINT64_C(0x7f7f7f00c7008000));
      clear_neon_saturated();
      //  Expect: "result" = 0080260037008000
      result = vmul_u8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u8(result), 0);
      exp = UINT64_C(0x0080260037008000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_148() {

{
   {
      uint16x4_t arg1;
      uint16x4_t arg2;
      uint16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"mul\", fnname = \"vmul_u16\", rettype = \"uint16x4_t\", argtypes = \"[uint16x4_t,uint16x4_t]\", vals = [VectorVal [IntegerVal 0,IntegerVal 0,IntegerVal 5015,IntegerVal 10482],VectorVal [IntegerVal 32768,IntegerVal 31320,IntegerVal 65535,IntegerVal 0]], start_saturated = True}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u16(UINT64_C(0x28f2139700000000));
      arg2 = vcreate_u16(UINT64_C(0x0000ffff7a588000));
      set_neon_saturated();
      //  Expect: "result" = 0000ec6900000000
      result = vmul_u16(arg1, arg2);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u16(result), 0);
      exp = UINT64_C(0x0000ec6900000000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_149() {

{
   {
      uint32x2_t arg1;
      uint32x2_t arg2;
      uint32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"mul\", fnname = \"vmul_u32\", rettype = \"uint32x2_t\", argtypes = \"[uint32x2_t,uint32x2_t]\", vals = [VectorVal [IntegerVal 4294901760,IntegerVal 32767],VectorVal [IntegerVal 2147483648,IntegerVal 573898751]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u32(UINT64_C(0x00007fffffff0000));
      arg2 = vcreate_u32(UINT64_C(0x2234ffff80000000));
      clear_neon_saturated();
      //  Expect: "result" = 5dca800100000000
      result = vmul_u32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u32(result), 0);
      exp = UINT64_C(0x5dca800100000000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_150() {

{
   {
      poly8x8_t arg1;
      poly8x8_t arg2;
      poly8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"mul\", fnname = \"vmul_p8\", rettype = \"poly8x8_t\", argtypes = \"[poly8x8_t,poly8x8_t]\", vals = [VectorVal [PolyVal [1,1,0,1,1,0,0,0],PolyVal [1,0,0,1,1,1,0,0],PolyVal [0,0,1,0,1,1,1,1],PolyVal [0,1,1,1,1,1,0,1],PolyVal [1,1,0,1,0,0,0,1],PolyVal [1,1,1,0,0,0,1,0],PolyVal [0,0,1,0,1,0,1,0],PolyVal [0,0,1,1,0,1,1,0]],VectorVal [PolyVal [1,1,0,0,1,0,0,0],PolyVal [0,0,0,0,1,0,0,0],PolyVal [1,1,0,1,0,0,0,1],PolyVal [1,0,1,0,0,1,1,1],PolyVal [1,0,1,0,1,1,1,1],PolyVal [1,1,0,0,1,1,1,0],PolyVal [0,1,1,1,1,1,1,1],PolyVal [0,0,1,1,0,0,0,1]]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_p8(UINT64_C(0x6c54478bbef4391b));
      arg2 = vcreate_p8(UINT64_C(0x8cfe73f5e58b1013));
      clear_neon_saturated();
      //  Expect: "result" = d098993706bc909d
      result = vmul_p8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_p8(result), 0);
      exp = UINT64_C(0xd098993706bc909d);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_151() {

{
   {
      int8x16_t arg1;
      int8x16_t arg2;
      int8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"mul\", fnname = \"vmulq_s8\", rettype = \"int8x16_t\", argtypes = \"[int8x16_t,int8x16_t]\", vals = [VectorVal [IntegerVal (-1),IntegerVal (-128),IntegerVal (-128),IntegerVal (-57),IntegerVal 84,IntegerVal 0,IntegerVal (-128),IntegerVal (-1),IntegerVal 7,IntegerVal (-128),IntegerVal 0,IntegerVal 127,IntegerVal 75,IntegerVal (-128),IntegerVal (-128),IntegerVal 0],VectorVal [IntegerVal 127,IntegerVal (-128),IntegerVal 0,IntegerVal 127,IntegerVal 0,IntegerVal 127,IntegerVal 124,IntegerVal (-128),IntegerVal (-1),IntegerVal (-44),IntegerVal (-128),IntegerVal (-128),IntegerVal 67,IntegerVal (-128),IntegerVal (-128),IntegerVal (-128)]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s8(vcreate_s8(UINT64_C(0xff800054c78080ff)),
                         vcreate_s8(UINT64_C(0x0080804b7f008007)));
      arg2 = vcombine_s8(vcreate_s8(UINT64_C(0x807c7f007f00807f)),
                         vcreate_s8(UINT64_C(0x808080438080d4ff)));
      clear_neon_saturated();
      //  Expect: "result" = 000000a1800000f980000000b9000081
      result = vmulq_s8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result), 0);
         exp = UINT64_C(0x80000000b9000081);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result), 1);
         exp = UINT64_C(0x000000a1800000f9);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_152() {

{
   {
      int16x8_t arg1;
      int16x8_t arg2;
      int16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"mul\", fnname = \"vmulq_s16\", rettype = \"int16x8_t\", argtypes = \"[int16x8_t,int16x8_t]\", vals = [VectorVal [IntegerVal 12293,IntegerVal (-1),IntegerVal (-32768),IntegerVal (-1),IntegerVal (-1),IntegerVal (-32768),IntegerVal (-1),IntegerVal (-1)],VectorVal [IntegerVal (-14902),IntegerVal 32767,IntegerVal (-1),IntegerVal 0,IntegerVal (-1),IntegerVal 32767,IntegerVal (-32768),IntegerVal 14637]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s16(vcreate_s16(UINT64_C(0xffff8000ffff3005)),
                          vcreate_s16(UINT64_C(0xffffffff8000ffff)));
      arg2 = vcombine_s16(vcreate_s16(UINT64_C(0x0000ffff7fffc5ca)),
                          vcreate_s16(UINT64_C(0x392d80007fffffff)));
      clear_neon_saturated();
      //  Expect: "result" = c6d3800080000001000080008001bcf2
      result = vmulq_s16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 0);
         exp = UINT64_C(0x000080008001bcf2);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 1);
         exp = UINT64_C(0xc6d3800080000001);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_153() {

{
   {
      int32x4_t arg1;
      int32x4_t arg2;
      int32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"mul\", fnname = \"vmulq_s32\", rettype = \"int32x4_t\", argtypes = \"[int32x4_t,int32x4_t]\", vals = [VectorVal [IntegerVal 44637,IntegerVal 2147483647,IntegerVal 1577385984,IntegerVal 1897049551],VectorVal [IntegerVal 2147482479,IntegerVal (-2147450880),IntegerVal 1609492388,IntegerVal 32767]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s32(vcreate_s32(UINT64_C(0x7fffffff0000ae5d)),
                          vcreate_s32(UINT64_C(0x7112adcf5e050000)));
      arg2 = vcombine_s32(vcreate_s32(UINT64_C(0x800080007ffffb6f)),
                          vcreate_s32(UINT64_C(0x00007fff5feee7a4)));
      clear_neon_saturated();
      //  Expect: "result" = e5d4d231be3400007fff80007ce3c953
      result = vmulq_s32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 0);
         exp = UINT64_C(0x7fff80007ce3c953);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 1);
         exp = UINT64_C(0xe5d4d231be340000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_154() {

{
   {
      float32x4_t arg1;
      float32x4_t arg2;
      float32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"mul\", fnname = \"vmulq_f32\", rettype = \"float32x4_t\", argtypes = \"[float32x4_t,float32x4_t]\", vals = [VectorVal [FloatVal 0.5192524790763855,FloatVal 0.6874197721481323,FloatVal 0.13385248184204102,FloatVal 0.7150024175643921],VectorVal [FloatVal 0.9502118229866028,FloatVal 0.25896841287612915,FloatVal 0.9825602769851685,FloatVal 0.2639363408088684]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_f32(vcreate_f32(UINT64_C(0x3f2ffabe3f04edbb)),
                          vcreate_f32(UINT64_C(0x3f370a663e0910a0)));
      arg2 = vcombine_f32(vcreate_f32(UINT64_C(0x3e8497823f734115)),
                          vcreate_f32(UINT64_C(0x3e8722aa3f7b8912)));
      clear_neon_saturated();
      //  Expect: "result" = 3e413e893e06acb03e364ae03efc9ee8
      result = vmulq_f32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 0);
         exp = ((float32_t) 0.49339985847473145);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 1);
         exp = ((float32_t) 0.17802000045776367);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 2);
         exp = ((float32_t) 0.13151812553405762);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 2 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 3);
         exp = ((float32_t) 0.1887151151895523);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 3 ", exp, got);
            }
      }
   }
}
}
void dotests_155() {

{
   {
      uint8x16_t arg1;
      uint8x16_t arg2;
      uint8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"mul\", fnname = \"vmulq_u8\", rettype = \"uint8x16_t\", argtypes = \"[uint8x16_t,uint8x16_t]\", vals = [VectorVal [IntegerVal 0,IntegerVal 127,IntegerVal 128,IntegerVal 127,IntegerVal 255,IntegerVal 0,IntegerVal 0,IntegerVal 255,IntegerVal 0,IntegerVal 127,IntegerVal 119,IntegerVal 128,IntegerVal 255,IntegerVal 128,IntegerVal 0,IntegerVal 0],VectorVal [IntegerVal 127,IntegerVal 128,IntegerVal 128,IntegerVal 0,IntegerVal 0,IntegerVal 161,IntegerVal 105,IntegerVal 127,IntegerVal 127,IntegerVal 128,IntegerVal 255,IntegerVal 127,IntegerVal 255,IntegerVal 165,IntegerVal 127,IntegerVal 127]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u8(vcreate_u8(UINT64_C(0xff0000ff7f807f00)),
                         vcreate_u8(UINT64_C(0x000080ff80777f00)));
      arg2 = vcombine_u8(vcreate_u8(UINT64_C(0x7f69a1000080807f)),
                         vcreate_u8(UINT64_C(0x7f7fa5ff7fff807f)));
      clear_neon_saturated();
      //  Expect: "result" = 00008001808980008100000000008000
      result = vmulq_u8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 0);
         exp = UINT64_C(0x8100000000008000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 1);
         exp = UINT64_C(0x0000800180898000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_156() {

{
   {
      uint16x8_t arg1;
      uint16x8_t arg2;
      uint16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"mul\", fnname = \"vmulq_u16\", rettype = \"uint16x8_t\", argtypes = \"[uint16x8_t,uint16x8_t]\", vals = [VectorVal [IntegerVal 32767,IntegerVal 32768,IntegerVal 32767,IntegerVal 32767,IntegerVal 0,IntegerVal 63401,IntegerVal 65535,IntegerVal 65535],VectorVal [IntegerVal 0,IntegerVal 10420,IntegerVal 65535,IntegerVal 0,IntegerVal 32768,IntegerVal 32767,IntegerVal 0,IntegerVal 0]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u16(vcreate_u16(UINT64_C(0x7fff7fff80007fff)),
                          vcreate_u16(UINT64_C(0xfffffffff7a90000)));
      arg2 = vcombine_u16(vcreate_u16(UINT64_C(0x0000ffff28b40000)),
                          vcreate_u16(UINT64_C(0x000000007fff8000)));
      clear_neon_saturated();
      //  Expect: "result" = 00000000885700000000800100000000
      result = vmulq_u16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 0);
         exp = UINT64_C(0x0000800100000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 1);
         exp = UINT64_C(0x0000000088570000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_157() {

{
   {
      uint32x4_t arg1;
      uint32x4_t arg2;
      uint32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"mul\", fnname = \"vmulq_u32\", rettype = \"uint32x4_t\", argtypes = \"[uint32x4_t,uint32x4_t]\", vals = [VectorVal [IntegerVal 2147516415,IntegerVal 2147528101,IntegerVal 32768,IntegerVal 2147483648],VectorVal [IntegerVal 4294955062,IntegerVal 32767,IntegerVal 2147483648,IntegerVal 2147472130]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u32(vcreate_u32(UINT64_C(0x8000ada580007fff)),
                          vcreate_u32(UINT64_C(0x8000000000008000)));
      arg2 = vcombine_u32(vcreate_u32(UINT64_C(0x00007fffffffd036)),
                          vcreate_u32(UINT64_C(0x7fffd30280000000)));
      clear_neon_saturated();
      //  Expect: "result" = 0000000000000000d6d1d25be81b2fca
      result = vmulq_u32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 0);
         exp = UINT64_C(0xd6d1d25be81b2fca);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 1);
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_158() {

{
   {
      poly8x16_t arg1;
      poly8x16_t arg2;
      poly8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"mul\", fnname = \"vmulq_p8\", rettype = \"poly8x16_t\", argtypes = \"[poly8x16_t,poly8x16_t]\", vals = [VectorVal [PolyVal [0,1,1,1,1,0,0,1],PolyVal [0,1,1,0,1,0,1,0],PolyVal [0,1,0,0,1,1,0,1],PolyVal [1,0,0,0,1,0,0,0],PolyVal [0,0,0,0,1,1,0,1],PolyVal [0,0,1,1,1,0,0,0],PolyVal [1,1,1,1,1,1,1,1],PolyVal [1,0,1,0,0,0,0,0],PolyVal [0,1,1,0,0,1,1,0],PolyVal [0,1,1,1,1,0,1,1],PolyVal [0,1,0,0,0,0,0,0],PolyVal [0,1,1,0,1,0,1,1],PolyVal [1,0,0,0,1,1,0,1],PolyVal [0,0,1,1,0,0,1,1],PolyVal [1,1,0,0,0,1,1,1],PolyVal [1,0,1,1,0,0,1,0]],VectorVal [PolyVal [0,1,0,0,1,0,0,0],PolyVal [0,0,0,1,0,1,0,1],PolyVal [0,0,1,0,1,0,0,0],PolyVal [1,0,1,1,1,1,1,0],PolyVal [0,1,0,1,0,1,1,0],PolyVal [1,0,0,1,1,0,1,0],PolyVal [1,0,1,1,0,0,0,0],PolyVal [1,1,0,1,1,0,0,1],PolyVal [1,1,0,0,0,1,1,1],PolyVal [0,0,1,0,1,0,1,0],PolyVal [0,0,1,0,0,1,1,0],PolyVal [1,1,0,0,0,1,0,1],PolyVal [1,1,1,0,1,1,1,0],PolyVal [0,0,1,1,0,0,0,1],PolyVal [1,0,1,1,1,0,0,0],PolyVal [0,0,1,1,0,1,0,0]]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_p8(vcreate_p8(UINT64_C(0x05ff1cb011b2569e)),
                         vcreate_p8(UINT64_C(0x4de3ccb1d602de66)));
      arg2 = vcombine_p8(vcreate_p8(UINT64_C(0x9b0d596a7d14a812)),
                         vcreate_p8(UINT64_C(0x2c1d8c77a36454e3)));
      clear_neon_saturated();
      //  Expect: "result" = fc475067bac818eaf7fb3ce0ade870dc
      result = vmulq_p8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p8(result), 0);
         exp = UINT64_C(0xf7fb3ce0ade870dc);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p8(result), 1);
         exp = UINT64_C(0xfc475067bac818ea);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_159() {

{
   {
      float64x1_t arg1;
      float64x1_t arg2;
      float64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"mul\", fnname = \"vmul_f64\", rettype = \"float64x1_t\", argtypes = \"[float64x1_t,float64x1_t]\", vals = [VectorVal [FloatVal 0.24574326407743374],VectorVal [FloatVal 0.7338272593187489]], start_saturated = False}";
      int reported = 0;
      float64_t got;
      float64_t exp;
      arg1 = vcreate_f64(UINT64_C(0x3fcf7483e9366220));
      arg2 = vcreate_f64(UINT64_C(0x3fe77b834df5feac));
      clear_neon_saturated();
      //  Expect: "result" = 3fc71527bc45ae18
      result = vmul_f64(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_f64(result, 0);
      exp = 0.18033310597398677;
      if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
         }
   }
}
}
void dotests_160() {

{
   {
      float64x2_t arg1;
      float64x2_t arg2;
      float64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"mul\", fnname = \"vmulq_f64\", rettype = \"float64x2_t\", argtypes = \"[float64x2_t,float64x2_t]\", vals = [VectorVal [FloatVal 0.5282711911118664,FloatVal 0.21838090102007368],VectorVal [FloatVal 0.7794159105630826,FloatVal 0.2216736436952591]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_f64(vcreate_f64(UINT64_C(0x3fe0e798fc27d263)),
                          vcreate_f64(UINT64_C(0x3fcbf3e7c5f9e2a8)));
      arg2 = vcombine_f64(vcreate_f64(UINT64_C(0x3fe8f0f9a2bb374d)),
                          vcreate_f64(UINT64_C(0x3fcc5fcd4d0734a8)));
      clear_neon_saturated();
      //  Expect: "result" = 3fa8c91a3b1c61833fda59ff312d9f47
      result = vmulq_f64(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float64_t got;
         float64_t exp;
         got = vgetq_lane_f64(result, 0);
         exp = 0.41174297144469957;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float64_t got;
         float64_t exp;
         got = vgetq_lane_f64(result, 1);
         exp = 4.840929004257346e-2;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
   }
}
}
void dotests_161() {

{
   {
      float32x2_t arg1;
      float32x2_t arg2;
      float32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"mulx\", fnname = \"vmulx_f32\", rettype = \"float32x2_t\", argtypes = \"[float32x2_t,float32x2_t]\", vals = [VectorVal [FloatVal 0.9114170670509338,FloatVal 4.282456636428833e-2],VectorVal [FloatVal 0.21795672178268433,FloatVal 0.2854704260826111]], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_f32(UINT64_C(0x3d2f68d03f6952a1));
      arg2 = vcreate_f32(UINT64_C(0x3e92292e3e5f300c));
      clear_neon_saturated();
      //  Expect: "result" = 3c484bfc3e4b6ac5
      result = vmulx_f32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result, 0);
         exp = ((float32_t) 0.19864948093891144);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result, 1);
         exp = ((float32_t) 1.222514733672142e-2);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
   }
}
}
void dotests_162() {

{
   {
      float64x1_t arg1;
      float64x1_t arg2;
      float64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"mulx\", fnname = \"vmulx_f64\", rettype = \"float64x1_t\", argtypes = \"[float64x1_t,float64x1_t]\", vals = [VectorVal [FloatVal 0.21725456272085408],VectorVal [FloatVal 0.7407062564771136]], start_saturated = False}";
      int reported = 0;
      float64_t got;
      float64_t exp;
      arg1 = vcreate_f64(UINT64_C(0x3fcbceff5ce57c14));
      arg2 = vcreate_f64(UINT64_C(0x3fe7b3dd9b706098));
      clear_neon_saturated();
      //  Expect: "result" = 3fc4991603dc7bc6
      result = vmulx_f64(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_f64(result, 0);
      exp = 0.1609218138555361;
      if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
         }
   }
}
}
void dotests_163() {

{
   {
      float32x4_t arg1;
      float32x4_t arg2;
      float32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"mulx\", fnname = \"vmulxq_f32\", rettype = \"float32x4_t\", argtypes = \"[float32x4_t,float32x4_t]\", vals = [VectorVal [FloatVal 0.38123202323913574,FloatVal 0.38664060831069946,FloatVal 0.892707884311676,FloatVal 0.2679207921028137],VectorVal [FloatVal 5.2255451679229736e-2,FloatVal 0.3203023672103882,FloatVal 0.5177145600318909,FloatVal 0.36064422130584717]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_f32(vcreate_f32(UINT64_C(0x3ec5f5c23ec330d8)),
                          vcreate_f32(UINT64_C(0x3e892cea3f648881)));
      arg2 = vcombine_f32(vcreate_f32(UINT64_C(0x3ea3feac3d5609d0)),
                          vcreate_f32(UINT64_C(0x3eb8a65c3f0488f1)));
      clear_neon_saturated();
      //  Expect: "result" = 3dc5e2d93eeca1443dfda0d33ca33250
      result = vmulxq_f32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 0);
         exp = ((float32_t) 1.9921451807022095e-2);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 1);
         exp = ((float32_t) 0.12384190410375595);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 2);
         exp = ((float32_t) 0.4621678590774536);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 2 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 3);
         exp = ((float32_t) 9.662408381700516e-2);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 3 ", exp, got);
            }
      }
   }
}
}
void dotests_164() {

{
   {
      float64x2_t arg1;
      float64x2_t arg2;
      float64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"mulx\", fnname = \"vmulxq_f64\", rettype = \"float64x2_t\", argtypes = \"[float64x2_t,float64x2_t]\", vals = [VectorVal [FloatVal 0.7701882665996651,FloatVal 0.3714954672011004],VectorVal [FloatVal 0.4738158593183568,FloatVal 0.5629370150711849]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_f64(vcreate_f64(UINT64_C(0x3fe8a561dd19df28)),
                          vcreate_f64(UINT64_C(0x3fd7c694ec8f6c00)));
      arg2 = vcombine_f64(vcreate_f64(UINT64_C(0x3fde52ffc1064d7c)),
                          vcreate_f64(UINT64_C(0x3fe203947cae08ff)));
      clear_neon_saturated();
      //  Expect: "result" = 3fcac4b96c34dfae3fd75af8849cfe55
      result = vmulxq_f64(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float64_t got;
         float64_t exp;
         got = vgetq_lane_f64(result, 0);
         exp = 0.364927415375836;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float64_t got;
         float64_t exp;
         got = vgetq_lane_f64(result, 1);
         exp = 0.2091285494186627;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
   }
}
}
void dotests_165() {

{
   {
      float32_t arg1;
      float32_t arg2;
      float32_t result;
      char* str1 = "ReproInfo2 {semantics = \"mulx\", fnname = \"vmulxs_f32\", rettype = \"float32_t\", argtypes = \"[float32_t,float32_t]\", vals = [FloatVal 0.5359081029891968,FloatVal 0.5533544421195984], start_saturated = False}";
      int reported = 0;
      float32_t got;
      float32_t exp;
      arg1 = ((float32_t) 0.5359081029891968);
      arg2 = ((float32_t) 0.5533544421195984);
      clear_neon_saturated();
      //  Expect: "result" = 3e97d506
      result = vmulxs_f32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = ((float32_t) 0.2965471148490906);
      if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %f Got: %f\n", "   ", exp, got);
         }
   }
}
}
void dotests_166() {

{
   {
      float64_t arg1;
      float64_t arg2;
      float64_t result;
      char* str1 = "ReproInfo2 {semantics = \"mulx\", fnname = \"vmulxd_f64\", rettype = \"float64_t\", argtypes = \"[float64_t,float64_t]\", vals = [FloatVal 7.686030867368787e-2,FloatVal 0.6759700411672562], start_saturated = False}";
      int reported = 0;
      float64_t got;
      float64_t exp;
      arg1 = 7.686030867368787e-2;
      arg2 = 0.6759700411672562;
      clear_neon_saturated();
      //  Expect: "result" = 3faa99e170ce970f
      result = vmulxd_f64(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = 5.1955266018280814e-2;
      if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %f Got: %f\n", "   ", exp, got);
         }
   }
}
}
void dotests_167() {

{
   {
      int8x8_t arg1;
      int8x8_t arg2;
      int8x8_t arg3;
      int8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"mla\", fnname = \"vmla_s8\", rettype = \"int8x8_t\", argtypes = \"[int8x8_t,int8x8_t,int8x8_t]\", vals = [VectorVal [IntegerVal (-128),IntegerVal 0,IntegerVal (-128),IntegerVal (-1),IntegerVal 127,IntegerVal 123,IntegerVal (-79),IntegerVal 0],VectorVal [IntegerVal 95,IntegerVal 127,IntegerVal 127,IntegerVal (-128),IntegerVal (-41),IntegerVal 0,IntegerVal 127,IntegerVal (-128)],VectorVal [IntegerVal 127,IntegerVal (-1),IntegerVal (-26),IntegerVal 0,IntegerVal (-114),IntegerVal (-1),IntegerVal (-128),IntegerVal (-128)]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s8(UINT64_C(0x00b17b7fff800080));
      arg2 = vcreate_s8(UINT64_C(0x807f00d7807f7f5f));
      arg3 = vcreate_s8(UINT64_C(0x8080ff8e00e6ff7f));
      clear_neon_saturated();
      //  Expect: "result" = 00317bc1ff9a81a1
      result = vmla_s8(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s8(result), 0);
      exp = UINT64_C(0x00317bc1ff9a81a1);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_168() {

{
   {
      int16x4_t arg1;
      int16x4_t arg2;
      int16x4_t arg3;
      int16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"mla\", fnname = \"vmla_s16\", rettype = \"int16x4_t\", argtypes = \"[int16x4_t,int16x4_t,int16x4_t]\", vals = [VectorVal [IntegerVal (-1),IntegerVal (-21535),IntegerVal (-32768),IntegerVal (-1)],VectorVal [IntegerVal (-1),IntegerVal (-32768),IntegerVal 0,IntegerVal (-1)],VectorVal [IntegerVal 2673,IntegerVal 9349,IntegerVal 32767,IntegerVal (-32768)]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s16(UINT64_C(0xffff8000abe1ffff));
      arg2 = vcreate_s16(UINT64_C(0xffff00008000ffff));
      arg3 = vcreate_s16(UINT64_C(0x80007fff24850a71));
      clear_neon_saturated();
      //  Expect: "result" = 7fff80002be1f58e
      result = vmla_s16(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s16(result), 0);
      exp = UINT64_C(0x7fff80002be1f58e);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_169() {

{
   {
      int32x2_t arg1;
      int32x2_t arg2;
      int32x2_t arg3;
      int32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"mla\", fnname = \"vmla_s32\", rettype = \"int32x2_t\", argtypes = \"[int32x2_t,int32x2_t,int32x2_t]\", vals = [VectorVal [IntegerVal (-560604324),IntegerVal 2147450879],VectorVal [IntegerVal (-32769),IntegerVal 54423],VectorVal [IntegerVal (-32769),IntegerVal 2147450879]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s32(UINT64_C(0x7fff7fffde95db5c));
      arg2 = vcreate_s32(UINT64_C(0x0000d497ffff7fff));
      arg3 = vcreate_s32(UINT64_C(0x7fff7fffffff7fff));
      clear_neon_saturated();
      //  Expect: "result" = 95b32b681e96db5d
      result = vmla_s32(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s32(result), 0);
      exp = UINT64_C(0x95b32b681e96db5d);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_170() {

{
   {
      uint8x8_t arg1;
      uint8x8_t arg2;
      uint8x8_t arg3;
      uint8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"mla\", fnname = \"vmla_u8\", rettype = \"uint8x8_t\", argtypes = \"[uint8x8_t,uint8x8_t,uint8x8_t]\", vals = [VectorVal [IntegerVal 5,IntegerVal 0,IntegerVal 127,IntegerVal 113,IntegerVal 128,IntegerVal 0,IntegerVal 215,IntegerVal 128],VectorVal [IntegerVal 255,IntegerVal 255,IntegerVal 127,IntegerVal 255,IntegerVal 0,IntegerVal 128,IntegerVal 128,IntegerVal 255],VectorVal [IntegerVal 128,IntegerVal 255,IntegerVal 127,IntegerVal 255,IntegerVal 255,IntegerVal 0,IntegerVal 137,IntegerVal 255]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u8(UINT64_C(0x80d70080717f0005));
      arg2 = vcreate_u8(UINT64_C(0xff808000ff7fffff));
      arg3 = vcreate_u8(UINT64_C(0xff8900ffff7fff80));
      clear_neon_saturated();
      //  Expect: "result" = 8157008072800185
      result = vmla_u8(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u8(result), 0);
      exp = UINT64_C(0x8157008072800185);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_171() {

{
   {
      uint16x4_t arg1;
      uint16x4_t arg2;
      uint16x4_t arg3;
      uint16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"mla\", fnname = \"vmla_u16\", rettype = \"uint16x4_t\", argtypes = \"[uint16x4_t,uint16x4_t,uint16x4_t]\", vals = [VectorVal [IntegerVal 0,IntegerVal 65535,IntegerVal 0,IntegerVal 0],VectorVal [IntegerVal 0,IntegerVal 32768,IntegerVal 14478,IntegerVal 65535],VectorVal [IntegerVal 0,IntegerVal 23640,IntegerVal 44188,IntegerVal 0]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u16(UINT64_C(0x00000000ffff0000));
      arg2 = vcreate_u16(UINT64_C(0xffff388e80000000));
      arg3 = vcreate_u16(UINT64_C(0x0000ac9c5c580000));
      clear_neon_saturated();
      //  Expect: "result" = 0000de88ffff0000
      result = vmla_u16(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u16(result), 0);
      exp = UINT64_C(0x0000de88ffff0000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_172() {

{
   {
      uint32x2_t arg1;
      uint32x2_t arg2;
      uint32x2_t arg3;
      uint32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"mla\", fnname = \"vmla_u32\", rettype = \"uint32x2_t\", argtypes = \"[uint32x2_t,uint32x2_t,uint32x2_t]\", vals = [VectorVal [IntegerVal 2147514489,IntegerVal 2147516415],VectorVal [IntegerVal 65535,IntegerVal 2292318208],VectorVal [IntegerVal 2147450880,IntegerVal 4294901760]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u32(UINT64_C(0x80007fff80007879));
      arg2 = vcreate_u32(UINT64_C(0x88a200000000ffff));
      arg3 = vcreate_u32(UINT64_C(0xffff00007fff8000));
      clear_neon_saturated();
      //  Expect: "result" = 80007fff8000f879
      result = vmla_u32(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u32(result), 0);
      exp = UINT64_C(0x80007fff8000f879);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_173() {

{
   {
      int8x16_t arg1;
      int8x16_t arg2;
      int8x16_t arg3;
      int8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"mla\", fnname = \"vmlaq_s8\", rettype = \"int8x16_t\", argtypes = \"[int8x16_t,int8x16_t,int8x16_t]\", vals = [VectorVal [IntegerVal (-1),IntegerVal (-128),IntegerVal (-128),IntegerVal 0,IntegerVal (-128),IntegerVal 127,IntegerVal (-128),IntegerVal (-1),IntegerVal (-1),IntegerVal 127,IntegerVal 0,IntegerVal 0,IntegerVal (-48),IntegerVal (-128),IntegerVal 0,IntegerVal (-95)],VectorVal [IntegerVal 127,IntegerVal (-1),IntegerVal (-1),IntegerVal (-43),IntegerVal 127,IntegerVal 0,IntegerVal (-1),IntegerVal 0,IntegerVal 127,IntegerVal (-1),IntegerVal 127,IntegerVal (-1),IntegerVal 127,IntegerVal (-105),IntegerVal 0,IntegerVal 127],VectorVal [IntegerVal 0,IntegerVal (-128),IntegerVal 0,IntegerVal (-1),IntegerVal 102,IntegerVal (-128),IntegerVal 127,IntegerVal (-1),IntegerVal (-128),IntegerVal (-1),IntegerVal (-128),IntegerVal (-1),IntegerVal (-1),IntegerVal (-30),IntegerVal 59,IntegerVal 0]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s8(vcreate_s8(UINT64_C(0xff807f80008080ff)),
                         vcreate_s8(UINT64_C(0xa10080d000007fff)));
      arg2 = vcombine_s8(vcreate_s8(UINT64_C(0x00ff007fd5ffff7f)),
                         vcreate_s8(UINT64_C(0x7f00977fff7fff7f)));
      arg3 = vcombine_s8(vcreate_s8(UINT64_C(0xff7f8066ff008000)),
                         vcreate_s8(UINT64_C(0x003be2ffff80ff80)));
      clear_neon_saturated();
      //  Expect: "result" = a100ce510180807fff017f1a2b8000ff
      result = vmlaq_s8(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result), 0);
         exp = UINT64_C(0xff017f1a2b8000ff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result), 1);
         exp = UINT64_C(0xa100ce510180807f);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_174() {

{
   {
      int16x8_t arg1;
      int16x8_t arg2;
      int16x8_t arg3;
      int16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"mla\", fnname = \"vmlaq_s16\", rettype = \"int16x8_t\", argtypes = \"[int16x8_t,int16x8_t,int16x8_t]\", vals = [VectorVal [IntegerVal 32767,IntegerVal 32767,IntegerVal 0,IntegerVal 0,IntegerVal (-9346),IntegerVal 32767,IntegerVal 32767,IntegerVal (-32768)],VectorVal [IntegerVal (-1),IntegerVal (-1),IntegerVal (-32768),IntegerVal 8824,IntegerVal 0,IntegerVal 0,IntegerVal 32767,IntegerVal 32767],VectorVal [IntegerVal (-32768),IntegerVal 0,IntegerVal (-32768),IntegerVal (-5827),IntegerVal (-32768),IntegerVal 32767,IntegerVal 32767,IntegerVal 32188]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s16(vcreate_s16(UINT64_C(0x000000007fff7fff)),
                          vcreate_s16(UINT64_C(0x80007fff7fffdb7e)));
      arg2 = vcombine_s16(vcreate_s16(UINT64_C(0x22788000ffffffff)),
                          vcreate_s16(UINT64_C(0x7fff7fff00000000)));
      arg3 = vcombine_s16(vcreate_s16(UINT64_C(0xe93d800000008000)),
                          vcreate_s16(UINT64_C(0x7dbc7fff7fff8000)));
      clear_neon_saturated();
      //  Expect: "result" = 024480007fffdb7e6e9800007fffffff
      result = vmlaq_s16(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 0);
         exp = UINT64_C(0x6e9800007fffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 1);
         exp = UINT64_C(0x024480007fffdb7e);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_175() {

{
   {
      int32x4_t arg1;
      int32x4_t arg2;
      int32x4_t arg3;
      int32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"mla\", fnname = \"vmlaq_s32\", rettype = \"int32x4_t\", argtypes = \"[int32x4_t,int32x4_t,int32x4_t]\", vals = [VectorVal [IntegerVal 2147483647,IntegerVal 2147418112,IntegerVal (-2147461487),IntegerVal (-2147483648)],VectorVal [IntegerVal 32768,IntegerVal (-32768),IntegerVal 0,IntegerVal (-32769)],VectorVal [IntegerVal (-1),IntegerVal (-1),IntegerVal (-65536),IntegerVal (-32768)]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s32(vcreate_s32(UINT64_C(0x7fff00007fffffff)),
                          vcreate_s32(UINT64_C(0x8000000080005691)));
      arg2 = vcombine_s32(vcreate_s32(UINT64_C(0xffff800000008000)),
                          vcreate_s32(UINT64_C(0xffff7fff00000000)));
      arg3 = vcombine_s32(vcreate_s32(UINT64_C(0xffffffffffffffff)),
                          vcreate_s32(UINT64_C(0xffff8000ffff0000)));
      clear_neon_saturated();
      //  Expect: "result" = c0008000800056917fff80007fff7fff
      result = vmlaq_s32(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 0);
         exp = UINT64_C(0x7fff80007fff7fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 1);
         exp = UINT64_C(0xc000800080005691);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_176() {

{
   {
      uint8x16_t arg1;
      uint8x16_t arg2;
      uint8x16_t arg3;
      uint8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"mla\", fnname = \"vmlaq_u8\", rettype = \"uint8x16_t\", argtypes = \"[uint8x16_t,uint8x16_t,uint8x16_t]\", vals = [VectorVal [IntegerVal 127,IntegerVal 127,IntegerVal 255,IntegerVal 0,IntegerVal 127,IntegerVal 127,IntegerVal 127,IntegerVal 34,IntegerVal 127,IntegerVal 0,IntegerVal 0,IntegerVal 127,IntegerVal 255,IntegerVal 0,IntegerVal 127,IntegerVal 255],VectorVal [IntegerVal 128,IntegerVal 255,IntegerVal 255,IntegerVal 128,IntegerVal 127,IntegerVal 255,IntegerVal 255,IntegerVal 0,IntegerVal 128,IntegerVal 128,IntegerVal 255,IntegerVal 127,IntegerVal 128,IntegerVal 255,IntegerVal 107,IntegerVal 32],VectorVal [IntegerVal 117,IntegerVal 255,IntegerVal 127,IntegerVal 128,IntegerVal 255,IntegerVal 0,IntegerVal 255,IntegerVal 128,IntegerVal 171,IntegerVal 0,IntegerVal 128,IntegerVal 204,IntegerVal 124,IntegerVal 190,IntegerVal 255,IntegerVal 162]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u8(vcreate_u8(UINT64_C(0x227f7f7f00ff7f7f)),
                         vcreate_u8(UINT64_C(0xff7f00ff7f00007f)));
      arg2 = vcombine_u8(vcreate_u8(UINT64_C(0x00ffff7f80ffff80)),
                         vcreate_u8(UINT64_C(0x206bff807fff8080)));
      arg3 = vcombine_u8(vcreate_u8(UINT64_C(0x80ff00ff807fff75)),
                         vcreate_u8(UINT64_C(0xa2ffbe7ccc8000ab)));
      clear_neon_saturated();
      //  Expect: "result" = 3f1442ffb38000ff22807f00008080ff
      result = vmlaq_u8(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 0);
         exp = UINT64_C(0x22807f00008080ff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 1);
         exp = UINT64_C(0x3f1442ffb38000ff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_177() {

{
   {
      uint16x8_t arg1;
      uint16x8_t arg2;
      uint16x8_t arg3;
      uint16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"mla\", fnname = \"vmlaq_u16\", rettype = \"uint16x8_t\", argtypes = \"[uint16x8_t,uint16x8_t,uint16x8_t]\", vals = [VectorVal [IntegerVal 19965,IntegerVal 32767,IntegerVal 0,IntegerVal 32767,IntegerVal 32768,IntegerVal 32767,IntegerVal 32768,IntegerVal 32767],VectorVal [IntegerVal 32768,IntegerVal 65535,IntegerVal 32768,IntegerVal 32768,IntegerVal 443,IntegerVal 0,IntegerVal 8403,IntegerVal 32768],VectorVal [IntegerVal 65535,IntegerVal 0,IntegerVal 65535,IntegerVal 0,IntegerVal 32767,IntegerVal 32767,IntegerVal 65535,IntegerVal 32768]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u16(vcreate_u16(UINT64_C(0x7fff00007fff4dfd)),
                          vcreate_u16(UINT64_C(0x7fff80007fff8000)));
      arg2 = vcombine_u16(vcreate_u16(UINT64_C(0x80008000ffff8000)),
                          vcreate_u16(UINT64_C(0x800020d3000001bb)));
      arg3 = vcombine_u16(vcreate_u16(UINT64_C(0x0000ffff0000ffff)),
                          vcreate_u16(UINT64_C(0x8000ffff7fff7fff)));
      clear_neon_saturated();
      //  Expect: "result" = 7fff5f2d7ffffe457fff80007fffcdfd
      result = vmlaq_u16(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 0);
         exp = UINT64_C(0x7fff80007fffcdfd);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 1);
         exp = UINT64_C(0x7fff5f2d7ffffe45);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_178() {

{
   {
      uint32x4_t arg1;
      uint32x4_t arg2;
      uint32x4_t arg3;
      uint32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"mla\", fnname = \"vmlaq_u32\", rettype = \"uint32x4_t\", argtypes = \"[uint32x4_t,uint32x4_t,uint32x4_t]\", vals = [VectorVal [IntegerVal 4294934527,IntegerVal 0,IntegerVal 4294901760,IntegerVal 614465536],VectorVal [IntegerVal 2147483648,IntegerVal 2147483648,IntegerVal 4294931689,IntegerVal 2147418112],VectorVal [IntegerVal 32768,IntegerVal 0,IntegerVal 42333,IntegerVal 2147511490]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u32(vcreate_u32(UINT64_C(0x00000000ffff7fff)),
                          vcreate_u32(UINT64_C(0x24a00000ffff0000)));
      arg2 = vcombine_u32(vcreate_u32(UINT64_C(0x8000000080000000)),
                          vcreate_u32(UINT64_C(0x7fff0000ffff74e9)));
      arg3 = vcombine_u32(vcreate_u32(UINT64_C(0x0000000000008000)),
                          vcreate_u32(UINT64_C(0x80006cc20000a55d)));
      clear_neon_saturated();
      //  Expect: "result" = b7de0000a626a5a500000000ffff7fff
      result = vmlaq_u32(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 0);
         exp = UINT64_C(0x00000000ffff7fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 1);
         exp = UINT64_C(0xb7de0000a626a5a5);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_179() {

{
   {
      float32x2_t arg1;
      float32x2_t arg2;
      float32x2_t arg3;
      float32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"mla\", fnname = \"vfma_f32\", rettype = \"float32x2_t\", argtypes = \"[float32x2_t,float32x2_t,float32x2_t]\", vals = [VectorVal [FloatVal 0.6816774010658264,FloatVal 0.1872469186782837],VectorVal [FloatVal 0.8370440006256104,FloatVal 0.832042396068573],VectorVal [FloatVal 0.4559548497200012,FloatVal 0.4626467227935791]], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_f32(UINT64_C(0x3e3fbda83f2e8269));
      arg2 = vcreate_f32(UINT64_C(0x3f5500bb3f564884));
      arg3 = vcreate_f32(UINT64_C(0x3eece0083ee972ea));
      clear_neon_saturated();
      //  Expect: "result" = 3f127af43f881b41
      result = vfma_f32(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result, 0);
         exp = ((float32_t) 1.0633317232131958);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result, 1);
         exp = ((float32_t) 0.5721886157989502);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
   }
}
}
void dotests_180() {

{
   {
      float32x4_t arg1;
      float32x4_t arg2;
      float32x4_t arg3;
      float32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"mla\", fnname = \"vfmaq_f32\", rettype = \"float32x4_t\", argtypes = \"[float32x4_t,float32x4_t,float32x4_t]\", vals = [VectorVal [FloatVal 0.646003782749176,FloatVal 0.20977479219436646,FloatVal 0.9382407665252686,FloatVal 0.16961604356765747],VectorVal [FloatVal 0.451129674911499,FloatVal 0.9493672251701355,FloatVal 0.6505329608917236,FloatVal 0.9197012186050415],VectorVal [FloatVal 0.49465763568878174,FloatVal 0.9820606708526611,FloatVal 0.48356926441192627,FloatVal 0.790895938873291]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_f32(vcreate_f32(UINT64_C(0x3e56cf343f256081)),
                          vcreate_f32(UINT64_C(0x3e2dafd43f70308c)));
      arg2 = vcombine_f32(vcreate_f32(UINT64_C(0x3f7309bb3ee6fa78)),
                          vcreate_f32(UINT64_C(0x3f6b718a3f268954)));
      arg3 = vcombine_f32(vcreate_f32(UINT64_C(0x3f7b68543efd43c4)),
                          vcreate_f32(UINT64_C(0x3f4a78283ef79664)));
      clear_neon_saturated();
      //  Expect: "result" = 3f65a20e3fa05c5b3f9230b23f5e812c
      result = vfmaq_f32(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 0);
         exp = ((float32_t) 0.8691585063934326);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 1);
         exp = ((float32_t) 1.14211106300354);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 2);
         exp = ((float32_t) 1.2528184652328491);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 2 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 3);
         exp = ((float32_t) 0.8970040082931519);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 3 ", exp, got);
            }
      }
   }
}
}
void dotests_181() {

{
   {
      float64x2_t arg1;
      float64x2_t arg2;
      float64x2_t arg3;
      float64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"mla\", fnname = \"vfmaq_f64\", rettype = \"float64x2_t\", argtypes = \"[float64x2_t,float64x2_t,float64x2_t]\", vals = [VectorVal [FloatVal 0.8560766867377201,FloatVal 0.700111108896245],VectorVal [FloatVal 0.7552425211492262,FloatVal 0.6176368786088501],VectorVal [FloatVal 0.21216571182409016,FloatVal 0.25495304625431137]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_f64(vcreate_f64(UINT64_C(0x3feb64faef8d026a)),
                          vcreate_f64(UINT64_C(0x3fe6674f6988d243)));
      arg2 = vcombine_f64(vcreate_f64(UINT64_C(0x3fe82af25d1c4df2)),
                          vcreate_f64(UINT64_C(0x3fe3c3ae6a4db68b)));
      arg3 = vcombine_f64(vcreate_f64(UINT64_C(0x3fcb283efccefac4)),
                          vcreate_f64(UINT64_C(0x3fd0512694eb61c6)));
      clear_neon_saturated();
      //  Expect: "result" = 3feb714a97078d6b3ff042d1afbb8d36
      result = vfmaq_f64(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float64_t got;
         float64_t exp;
         got = vgetq_lane_f64(result, 0);
         exp = 1.0163132538371662;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float64_t got;
         float64_t exp;
         got = vgetq_lane_f64(result, 1);
         exp = 0.8575795125765756;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
   }
}
}
void dotests_182() {

{
   {
      float64x1_t arg1;
      float64x1_t arg2;
      float64x1_t arg3;
      float64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"mla\", fnname = \"vfma_f64\", rettype = \"float64x1_t\", argtypes = \"[float64x1_t,float64x1_t,float64x1_t]\", vals = [VectorVal [FloatVal 0.6841847921940517],VectorVal [FloatVal 0.16055718104871064],VectorVal [FloatVal 0.32731033977065116]], start_saturated = False}";
      int reported = 0;
      float64_t got;
      float64_t exp;
      arg1 = vcreate_f64(UINT64_C(0x3fe5e4d7815c9bb7));
      arg2 = vcreate_f64(UINT64_C(0x3fc48d2340deff34));
      arg3 = vcreate_f64(UINT64_C(0x3fd4f2a7113d493c));
      clear_neon_saturated();
      //  Expect: "result" = 3fe793591735a4a0
      result = vfma_f64(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_f64(result, 0);
      exp = 0.7367368176757232;
      if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
         }
   }
}
}
void dotests_183() {

{
   {
      float32x2_t arg1;
      float32x2_t arg2;
      float32x2_t arg3;
      float32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"mla\", fnname = \"vmla_f32\", rettype = \"float32x2_t\", argtypes = \"[float32x2_t,float32x2_t,float32x2_t]\", vals = [VectorVal [FloatVal 0.8686251640319824,FloatVal 8.819437026977539e-2],VectorVal [FloatVal 8.273643255233765e-2,FloatVal 0.8943750262260437],VectorVal [FloatVal 0.6253815293312073,FloatVal 0.439550518989563]], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_f32(UINT64_C(0x3db49f403f5e5e38));
      arg2 = vcreate_f32(UINT64_C(0x3f64f5c33da971b8));
      arg3 = vcreate_f32(UINT64_C(0x3ee10cc43f201901));
      clear_neon_saturated();
      //  Expect: "result" = 3ef66f3b3f6b9d2c
      result = vmla_f32(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result, 0);
         exp = ((float32_t) 0.9203670024871826);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result, 1);
         exp = ((float32_t) 0.4813173711299896);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
   }
}
}
void dotests_184() {

{
   {
      float32x4_t arg1;
      float32x4_t arg2;
      float32x4_t arg3;
      float32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"mla\", fnname = \"vmlaq_f32\", rettype = \"float32x4_t\", argtypes = \"[float32x4_t,float32x4_t,float32x4_t]\", vals = [VectorVal [FloatVal 0.8419051170349121,FloatVal 0.3875741958618164,FloatVal 0.30864405632019043,FloatVal 0.9758923053741455],VectorVal [FloatVal 0.21739304065704346,FloatVal 0.5994455218315125,FloatVal 0.20237034559249878,FloatVal 0.11964911222457886],VectorVal [FloatVal 0.46991485357284546,FloatVal 0.11324018239974976,FloatVal 0.4986122250556946,FloatVal 0.7726595997810364]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_f32(vcreate_f32(UINT64_C(0x3ec670203f578718)),
                          vcreate_f32(UINT64_C(0x3f79d4143e9e0698)));
      arg2 = vcombine_f32(vcreate_f32(UINT64_C(0x3f1975433e5e9c48)),
                          vcreate_f32(UINT64_C(0x3df50a983e4f3a2c)));
      arg3 = vcombine_f32(vcreate_f32(UINT64_C(0x3de7ea783ef098ae)),
                          vcreate_f32(UINT64_C(0x3f45cd053eff4a1a)));
      clear_neon_saturated();
      //  Expect: "result" = 3f88bf603ed1b0533ee931773f71ae01
      result = vmlaq_f32(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 0);
         exp = ((float32_t) 0.9440613389015198);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 1);
         exp = ((float32_t) 0.4554555118083954);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 2);
         exp = ((float32_t) 0.4095483720302582);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 2 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 3);
         exp = ((float32_t) 1.0683403015136719);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 3 ", exp, got);
            }
      }
   }
}
}
void dotests_185() {

{
   {
      float64x2_t arg1;
      float64x2_t arg2;
      float64x2_t arg3;
      float64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"mla\", fnname = \"vmlaq_f64\", rettype = \"float64x2_t\", argtypes = \"[float64x2_t,float64x2_t,float64x2_t]\", vals = [VectorVal [FloatVal 0.25790008903029327,FloatVal 0.9719934866758558],VectorVal [FloatVal 0.6230205599330156,FloatVal 0.9749433731966858],VectorVal [FloatVal 1.8476889375302563e-2,FloatVal 0.35170675216548886]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_f64(vcreate_f64(UINT64_C(0x3fd0816f6001517a)),
                          vcreate_f64(UINT64_C(0x3fef1a9215a6547b)));
      arg2 = vcombine_f64(vcreate_f64(UINT64_C(0x3fe3efc8d034bbae)),
                          vcreate_f64(UINT64_C(0x3fef32bc71ea9d31)));
      arg3 = vcombine_f64(vcreate_f64(UINT64_C(0x3f92eb9b0e651aa0)),
                          vcreate_f64(UINT64_C(0x3fd6825d0995525c)));
      clear_neon_saturated();
      //  Expect: "result" = 3ff509c7a2fe10b03fd13e0a07a585a3
      result = vmlaq_f64(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float64_t got;
         float64_t exp;
         got = vgetq_lane_f64(result, 0);
         exp = 0.26941157099471463;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float64_t got;
         float64_t exp;
         got = vgetq_lane_f64(result, 1);
         exp = 1.3148876540081282;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
   }
}
}
void dotests_186() {

{
   {
      float64x1_t arg1;
      float64x1_t arg2;
      float64x1_t arg3;
      float64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"mla\", fnname = \"vmla_f64\", rettype = \"float64x1_t\", argtypes = \"[float64x1_t,float64x1_t,float64x1_t]\", vals = [VectorVal [FloatVal 0.3522100259880828],VectorVal [FloatVal 0.2371403955016521],VectorVal [FloatVal 0.8474060149039537]], start_saturated = False}";
      int reported = 0;
      float64_t got;
      float64_t exp;
      arg1 = vcreate_f64(UINT64_C(0x3fd68a9bebbc4bca));
      arg2 = vcreate_f64(UINT64_C(0x3fce5a9dd19ebba4));
      arg3 = vcreate_f64(UINT64_C(0x3feb1df3380e4706));
      clear_neon_saturated();
      //  Expect: "result" = 3fe1b3857529c330
      result = vmla_f64(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_f64(result, 0);
      exp = 0.5531642235128853;
      if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
         }
   }
}
}
void dotests_187() {

{
   {
      int16x8_t arg1;
      int8x8_t arg2;
      int8x8_t arg3;
      int16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"mla\", fnname = \"vmlal_s8\", rettype = \"int16x8_t\", argtypes = \"[int16x8_t,int8x8_t,int8x8_t]\", vals = [VectorVal [IntegerVal (-1),IntegerVal (-32768),IntegerVal (-32768),IntegerVal (-1),IntegerVal (-32768),IntegerVal 32767,IntegerVal 0,IntegerVal (-1)],VectorVal [IntegerVal (-1),IntegerVal (-1),IntegerVal (-128),IntegerVal (-128),IntegerVal 0,IntegerVal 0,IntegerVal (-1),IntegerVal (-112)],VectorVal [IntegerVal 127,IntegerVal 0,IntegerVal (-99),IntegerVal (-106),IntegerVal (-1),IntegerVal (-128),IntegerVal 0,IntegerVal (-1)]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s16(vcreate_s16(UINT64_C(0xffff80008000ffff)),
                          vcreate_s16(UINT64_C(0xffff00007fff8000)));
      arg2 = vcreate_s8(UINT64_C(0x90ff00008080ffff));
      arg3 = vcreate_s8(UINT64_C(0xff0080ff969d007f));
      clear_neon_saturated();
      //  Expect: "result" = 006f00007fff800034ffb1808000ff80
      result = vmlal_s8(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 0);
         exp = UINT64_C(0x34ffb1808000ff80);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 1);
         exp = UINT64_C(0x006f00007fff8000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_188() {

{
   {
      int32x4_t arg1;
      int16x4_t arg2;
      int16x4_t arg3;
      int32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"mla\", fnname = \"vmlal_s16\", rettype = \"int32x4_t\", argtypes = \"[int32x4_t,int16x4_t,int16x4_t]\", vals = [VectorVal [IntegerVal (-3601),IntegerVal 2147483647,IntegerVal (-1208975361),IntegerVal (-61875)],VectorVal [IntegerVal 32767,IntegerVal (-32768),IntegerVal 32767,IntegerVal 32767],VectorVal [IntegerVal 32302,IntegerVal 10208,IntegerVal 32767,IntegerVal (-31526)]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s32(vcreate_s32(UINT64_C(0x7ffffffffffff1ef)),
                          vcreate_s32(UINT64_C(0xffff0e4db7f07fff)));
      arg2 = vcreate_s16(UINT64_C(0x7fff7fff80007fff));
      arg3 = vcreate_s16(UINT64_C(0x84da7fff27e07e2e));
      clear_neon_saturated();
      //  Expect: "result" = c26c8973f7ef80006c0fffff3f1673c1
      result = vmlal_s16(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 0);
         exp = UINT64_C(0x6c0fffff3f1673c1);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 1);
         exp = UINT64_C(0xc26c8973f7ef8000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_189() {

{
   {
      int64x2_t arg1;
      int32x2_t arg2;
      int32x2_t arg3;
      int64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"mla\", fnname = \"vmlal_s32\", rettype = \"int64x2_t\", argtypes = \"[int64x2_t,int32x2_t,int32x2_t]\", vals = [VectorVal [IntegerVal 281470681808895,IntegerVal (-181770376773632)],VectorVal [IntegerVal (-32769),IntegerVal 32768],VectorVal [IntegerVal 32767,IntegerVal 2147483647]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s64(vcreate_s64(UINT64_C(0x0000ffff0000ffff)),
                          vcreate_s64(UINT64_C(0xffff5aae49430000)));
      arg2 = vcreate_s32(UINT64_C(0x00008000ffff7fff));
      arg3 = vcreate_s32(UINT64_C(0x7fffffff00007fff));
      clear_neon_saturated();
      //  Expect: "result" = ffff9aae494280000000fffec0010000
      result = vmlal_s32(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 0);
         exp = UINT64_C(0x0000fffec0010000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 1);
         exp = UINT64_C(0xffff9aae49428000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_190() {

{
   {
      uint16x8_t arg1;
      uint8x8_t arg2;
      uint8x8_t arg3;
      uint16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"mla\", fnname = \"vmlal_u8\", rettype = \"uint16x8_t\", argtypes = \"[uint16x8_t,uint8x8_t,uint8x8_t]\", vals = [VectorVal [IntegerVal 32767,IntegerVal 32768,IntegerVal 32767,IntegerVal 0,IntegerVal 32768,IntegerVal 65535,IntegerVal 65535,IntegerVal 35712],VectorVal [IntegerVal 255,IntegerVal 0,IntegerVal 71,IntegerVal 0,IntegerVal 128,IntegerVal 0,IntegerVal 41,IntegerVal 128],VectorVal [IntegerVal 0,IntegerVal 127,IntegerVal 128,IntegerVal 127,IntegerVal 129,IntegerVal 150,IntegerVal 255,IntegerVal 143]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u16(vcreate_u16(UINT64_C(0x00007fff80007fff)),
                          vcreate_u16(UINT64_C(0x8b80ffffffff8000)));
      arg2 = vcreate_u8(UINT64_C(0x80290080004700ff));
      arg3 = vcreate_u8(UINT64_C(0x8fff96817f807f00));
      clear_neon_saturated();
      //  Expect: "result" = d30028d6ffffc0800000a37f80007fff
      result = vmlal_u8(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 0);
         exp = UINT64_C(0x0000a37f80007fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 1);
         exp = UINT64_C(0xd30028d6ffffc080);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_191() {

{
   {
      uint32x4_t arg1;
      uint16x4_t arg2;
      uint16x4_t arg3;
      uint32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"mla\", fnname = \"vmlal_u16\", rettype = \"uint32x4_t\", argtypes = \"[uint32x4_t,uint16x4_t,uint16x4_t]\", vals = [VectorVal [IntegerVal 65535,IntegerVal 32768,IntegerVal 2147483648,IntegerVal 2147450880],VectorVal [IntegerVal 22690,IntegerVal 32767,IntegerVal 0,IntegerVal 6382],VectorVal [IntegerVal 0,IntegerVal 23896,IntegerVal 32767,IntegerVal 1283]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u32(vcreate_u32(UINT64_C(0x000080000000ffff)),
                          vcreate_u32(UINT64_C(0x7fff800080000000)));
      arg2 = vcreate_u16(UINT64_C(0x18ee00007fff58a2));
      arg3 = vcreate_u16(UINT64_C(0x05037fff5d580000));
      clear_neon_saturated();
      //  Expect: "result" = 807c70ca800000002eac22a80000ffff
      result = vmlal_u16(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 0);
         exp = UINT64_C(0x2eac22a80000ffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 1);
         exp = UINT64_C(0x807c70ca80000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_192() {

{
   {
      uint64x2_t arg1;
      uint32x2_t arg2;
      uint32x2_t arg3;
      uint64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"mla\", fnname = \"vmlal_u32\", rettype = \"uint64x2_t\", argtypes = \"[uint64x2_t,uint32x2_t,uint32x2_t]\", vals = [VectorVal [IntegerVal 140735340838911,IntegerVal 16705258389637136383],VectorVal [IntegerVal 65535,IntegerVal 4294901760],VectorVal [IntegerVal 32768,IntegerVal 2147484557]], start_saturated = True}";
      int reported = 0;
      arg1 = vcombine_u64(vcreate_u64(UINT64_C(0x00007fff7fff7fff)),
                          vcreate_u64(UINT64_C(0xe7d4ffff436f7fff)));
      arg2 = vcreate_u32(UINT64_C(0xffff00000000ffff));
      arg3 = vcreate_u32(UINT64_C(0x8000038d00008000));
      set_neon_saturated();
      //  Expect: "result" = 67d4838c3fe27fff00007ffffffeffff
      result = vmlal_u32(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 0);
         exp = UINT64_C(0x00007ffffffeffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 1);
         exp = UINT64_C(0x67d4838c3fe27fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_193() {

{
   {
      int16x8_t arg1;
      int8x16_t arg2;
      int8x16_t arg3;
      int16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"mla\", fnname = \"vmlal_high_s8\", rettype = \"int16x8_t\", argtypes = \"[int16x8_t,int8x16_t,int8x16_t]\", vals = [VectorVal [IntegerVal (-32768),IntegerVal (-7611),IntegerVal (-2383),IntegerVal 29259,IntegerVal (-32768),IntegerVal 32767,IntegerVal (-1),IntegerVal (-32768)],VectorVal [IntegerVal 127,IntegerVal (-1),IntegerVal 93,IntegerVal 0,IntegerVal 0,IntegerVal 127,IntegerVal 127,IntegerVal 127,IntegerVal 49,IntegerVal (-97),IntegerVal (-1),IntegerVal (-40),IntegerVal 0,IntegerVal (-1),IntegerVal 127,IntegerVal (-128)],VectorVal [IntegerVal (-88),IntegerVal (-128),IntegerVal (-1),IntegerVal (-1),IntegerVal 0,IntegerVal 0,IntegerVal 127,IntegerVal 0,IntegerVal (-128),IntegerVal (-128),IntegerVal (-128),IntegerVal (-128),IntegerVal (-128),IntegerVal (-1),IntegerVal 119,IntegerVal 0]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s16(vcreate_s16(UINT64_C(0x724bf6b1e2458000)),
                          vcreate_s16(UINT64_C(0x8000ffff7fff8000)));
      arg2 = vcombine_s8(vcreate_s8(UINT64_C(0x7f7f7f00005dff7f)),
                         vcreate_s8(UINT64_C(0x807fff00d8ff9f31)));
      arg3 = vcombine_s8(vcreate_s8(UINT64_C(0x007f0000ffff80a8)),
                         vcreate_s8(UINT64_C(0x0077ff8080808080)));
      clear_neon_saturated();
      //  Expect: "result" = 80003b0880008000864bf73112c56780
      result = vmlal_high_s8(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 0);
         exp = UINT64_C(0x864bf73112c56780);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 1);
         exp = UINT64_C(0x80003b0880008000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_194() {

{
   {
      int32x4_t arg1;
      int16x8_t arg2;
      int16x8_t arg3;
      int32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"mla\", fnname = \"vmlal_high_s16\", rettype = \"int32x4_t\", argtypes = \"[int32x4_t,int16x8_t,int16x8_t]\", vals = [VectorVal [IntegerVal 2147450880,IntegerVal 12334,IntegerVal 2147450880,IntegerVal (-2147450881)],VectorVal [IntegerVal 32767,IntegerVal (-1),IntegerVal (-32768),IntegerVal (-32768),IntegerVal 32767,IntegerVal (-1),IntegerVal (-32768),IntegerVal (-32768)],VectorVal [IntegerVal (-32768),IntegerVal 0,IntegerVal 32767,IntegerVal 32767,IntegerVal (-1),IntegerVal 0,IntegerVal (-1),IntegerVal (-32768)]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s32(vcreate_s32(UINT64_C(0x0000302e7fff8000)),
                          vcreate_s32(UINT64_C(0x80007fff7fff8000)));
      arg2 = vcombine_s16(vcreate_s16(UINT64_C(0x80008000ffff7fff)),
                          vcreate_s16(UINT64_C(0x80008000ffff7fff)));
      arg3 = vcombine_s16(vcreate_s16(UINT64_C(0x7fff7fff00008000)),
                          vcreate_s16(UINT64_C(0x8000ffff0000ffff)));
      clear_neon_saturated();
      //  Expect: "result" = c0007fff800000000000302e7fff0001
      result = vmlal_high_s16(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 0);
         exp = UINT64_C(0x0000302e7fff0001);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 1);
         exp = UINT64_C(0xc0007fff80000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_195() {

{
   {
      int64x2_t arg1;
      int32x4_t arg2;
      int32x4_t arg3;
      int64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"mla\", fnname = \"vmlal_high_s32\", rettype = \"int64x2_t\", argtypes = \"[int64x2_t,int32x4_t,int32x4_t]\", vals = [VectorVal [IntegerVal (-3952049412653481985),IntegerVal (-9223231301036900353)],VectorVal [IntegerVal 32768,IntegerVal (-65536),IntegerVal (-2147418113),IntegerVal 0],VectorVal [IntegerVal 33034,IntegerVal 2147483647,IntegerVal 2076593817,IntegerVal 2147418112]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s64(vcreate_s64(UINT64_C(0xc9277fff7fff7fff)),
                          vcreate_s64(UINT64_C(0x80007fff9c6e7fff)));
      arg2 = vcombine_s32(vcreate_s32(UINT64_C(0xffff000000008000)),
                          vcreate_s32(UINT64_C(0x000000008000ffff)));
      arg3 = vcombine_s32(vcreate_s32(UINT64_C(0x7fffffff0000810a)),
                          vcreate_s32(UINT64_C(0x7fff00007bc64e99)));
      clear_neon_saturated();
      //  Expect: "result" = 80007fff9c6e7fff8b44d478d2d23166
      result = vmlal_high_s32(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 0);
         exp = UINT64_C(0x8b44d478d2d23166);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 1);
         exp = UINT64_C(0x80007fff9c6e7fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_196() {

{
   {
      uint16x8_t arg1;
      uint8x16_t arg2;
      uint8x16_t arg3;
      uint16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"mla\", fnname = \"vmlal_high_u8\", rettype = \"uint16x8_t\", argtypes = \"[uint16x8_t,uint8x16_t,uint8x16_t]\", vals = [VectorVal [IntegerVal 0,IntegerVal 65535,IntegerVal 0,IntegerVal 0,IntegerVal 32767,IntegerVal 65535,IntegerVal 32768,IntegerVal 32767],VectorVal [IntegerVal 255,IntegerVal 0,IntegerVal 0,IntegerVal 0,IntegerVal 255,IntegerVal 127,IntegerVal 0,IntegerVal 128,IntegerVal 127,IntegerVal 205,IntegerVal 61,IntegerVal 128,IntegerVal 0,IntegerVal 127,IntegerVal 92,IntegerVal 255],VectorVal [IntegerVal 0,IntegerVal 128,IntegerVal 128,IntegerVal 0,IntegerVal 127,IntegerVal 127,IntegerVal 0,IntegerVal 127,IntegerVal 127,IntegerVal 159,IntegerVal 0,IntegerVal 255,IntegerVal 255,IntegerVal 0,IntegerVal 127,IntegerVal 0]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u16(vcreate_u16(UINT64_C(0x00000000ffff0000)),
                          vcreate_u16(UINT64_C(0x7fff8000ffff7fff)));
      arg2 = vcombine_u8(vcreate_u8(UINT64_C(0x80007fff000000ff)),
                         vcreate_u8(UINT64_C(0xff5c7f00803dcd7f)));
      arg3 = vcombine_u8(vcreate_u8(UINT64_C(0x7f007f7f00808000)),
                         vcreate_u8(UINT64_C(0x007f00ffff009f7f)));
      clear_neon_saturated();
      //  Expect: "result" = 7fffada4ffff7fff7f8000007f523f01
      result = vmlal_high_u8(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 0);
         exp = UINT64_C(0x7f8000007f523f01);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 1);
         exp = UINT64_C(0x7fffada4ffff7fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_197() {

{
   {
      uint32x4_t arg1;
      uint16x8_t arg2;
      uint16x8_t arg3;
      uint32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"mla\", fnname = \"vmlal_high_u16\", rettype = \"uint32x4_t\", argtypes = \"[uint32x4_t,uint16x8_t,uint16x8_t]\", vals = [VectorVal [IntegerVal 4294967295,IntegerVal 2147516415,IntegerVal 2147549183,IntegerVal 2147457244],VectorVal [IntegerVal 11650,IntegerVal 65535,IntegerVal 22745,IntegerVal 65535,IntegerVal 32767,IntegerVal 0,IntegerVal 0,IntegerVal 50452],VectorVal [IntegerVal 29127,IntegerVal 32767,IntegerVal 0,IntegerVal 25983,IntegerVal 0,IntegerVal 32768,IntegerVal 0,IntegerVal 34000]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u32(vcreate_u32(UINT64_C(0x80007fffffffffff)),
                          vcreate_u32(UINT64_C(0x7fff98dc8000ffff)));
      arg2 = vcombine_u16(vcreate_u16(UINT64_C(0xffff58d9ffff2d82)),
                          vcreate_u16(UINT64_C(0xc514000000007fff)));
      arg3 = vcombine_u16(vcreate_u16(UINT64_C(0x657f00007fff71c7)),
                          vcreate_u16(UINT64_C(0x84d0000080000000)));
      clear_neon_saturated();
      //  Expect: "result" = e63e091c8000ffff80007fffffffffff
      result = vmlal_high_u16(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 0);
         exp = UINT64_C(0x80007fffffffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 1);
         exp = UINT64_C(0xe63e091c8000ffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_198() {

{
   {
      uint64x2_t arg1;
      uint32x4_t arg2;
      uint32x4_t arg3;
      uint64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"mla\", fnname = \"vmlal_high_u32\", rettype = \"uint64x2_t\", argtypes = \"[uint64x2_t,uint32x4_t,uint32x4_t]\", vals = [VectorVal [IntegerVal 8820159134864244735,IntegerVal 18446603334073745407],VectorVal [IntegerVal 32767,IntegerVal 2147483647,IntegerVal 3547561983,IntegerVal 4294934528],VectorVal [IntegerVal 469172224,IntegerVal 1001546775,IntegerVal 848789504,IntegerVal 0]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u64(vcreate_u64(UINT64_C(0x7a6780007fffffff)),
                          vcreate_u64(UINT64_C(0xffff7fff80007fff)));
      arg2 = vcombine_u32(vcreate_u32(UINT64_C(0x7fffffff00007fff)),
                          vcreate_u32(UINT64_C(0xffff8000d3737fff)));
      arg3 = vcombine_u32(vcreate_u32(UINT64_C(0x3bb264171bf70000)),
                          vcreate_u32(UINT64_C(0x0000000032978000)));
      clear_neon_saturated();
      //  Expect: "result" = ffff7fff80007fffa43131da8d687fff
      result = vmlal_high_u32(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 0);
         exp = UINT64_C(0xa43131da8d687fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 1);
         exp = UINT64_C(0xffff7fff80007fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_199() {

{
   {
      int8x8_t arg1;
      int8x8_t arg2;
      int8x8_t arg3;
      int8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"mls\", fnname = \"vmls_s8\", rettype = \"int8x8_t\", argtypes = \"[int8x8_t,int8x8_t,int8x8_t]\", vals = [VectorVal [IntegerVal (-108),IntegerVal (-128),IntegerVal (-1),IntegerVal (-1),IntegerVal (-1),IntegerVal (-1),IntegerVal (-1),IntegerVal 0],VectorVal [IntegerVal (-1),IntegerVal (-128),IntegerVal 127,IntegerVal 0,IntegerVal (-128),IntegerVal (-1),IntegerVal (-128),IntegerVal (-113)],VectorVal [IntegerVal (-128),IntegerVal 127,IntegerVal (-128),IntegerVal (-1),IntegerVal 122,IntegerVal 0,IntegerVal 127,IntegerVal (-101)]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s8(UINT64_C(0x00ffffffffff8094));
      arg2 = vcreate_s8(UINT64_C(0x8f80ff80007f80ff));
      arg3 = vcreate_s8(UINT64_C(0x9b7f007aff807f80));
      clear_neon_saturated();
      //  Expect: "result" = 6b7fffffff7f0014
      result = vmls_s8(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s8(result), 0);
      exp = UINT64_C(0x6b7fffffff7f0014);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_200() {

{
   {
      int16x4_t arg1;
      int16x4_t arg2;
      int16x4_t arg3;
      int16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"mls\", fnname = \"vmls_s16\", rettype = \"int16x4_t\", argtypes = \"[int16x4_t,int16x4_t,int16x4_t]\", vals = [VectorVal [IntegerVal 32767,IntegerVal 32767,IntegerVal (-1),IntegerVal 0],VectorVal [IntegerVal 682,IntegerVal (-25352),IntegerVal (-1),IntegerVal (-1)],VectorVal [IntegerVal (-25999),IntegerVal 0,IntegerVal (-32768),IntegerVal (-1)]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s16(UINT64_C(0x0000ffff7fff7fff));
      arg2 = vcreate_s16(UINT64_C(0xffffffff9cf802aa));
      arg3 = vcreate_s16(UINT64_C(0xffff800000009a71));
      clear_neon_saturated();
      //  Expect: "result" = ffff7fff7fff0ef5
      result = vmls_s16(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s16(result), 0);
      exp = UINT64_C(0xffff7fff7fff0ef5);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_201() {

{
   {
      int32x2_t arg1;
      int32x2_t arg2;
      int32x2_t arg3;
      int32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"mls\", fnname = \"vmls_s32\", rettype = \"int32x2_t\", argtypes = \"[int32x2_t,int32x2_t,int32x2_t]\", vals = [VectorVal [IntegerVal (-2147418113),IntegerVal 2147483647],VectorVal [IntegerVal 32767,IntegerVal (-1379434497)],VectorVal [IntegerVal (-2147450880),IntegerVal 2147450879]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s32(UINT64_C(0x7fffffff8000ffff));
      arg2 = vcreate_s32(UINT64_C(0xadc77fff00007fff));
      arg3 = vcreate_s32(UINT64_C(0x7fff7fff80008000));
      clear_neon_saturated();
      //  Expect: "result" = 6dc6fffec0017fff
      result = vmls_s32(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s32(result), 0);
      exp = UINT64_C(0x6dc6fffec0017fff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_202() {

{
   {
      uint8x8_t arg1;
      uint8x8_t arg2;
      uint8x8_t arg3;
      uint8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"mls\", fnname = \"vmls_u8\", rettype = \"uint8x8_t\", argtypes = \"[uint8x8_t,uint8x8_t,uint8x8_t]\", vals = [VectorVal [IntegerVal 255,IntegerVal 55,IntegerVal 127,IntegerVal 255,IntegerVal 255,IntegerVal 127,IntegerVal 255,IntegerVal 144],VectorVal [IntegerVal 91,IntegerVal 0,IntegerVal 0,IntegerVal 74,IntegerVal 255,IntegerVal 0,IntegerVal 128,IntegerVal 194],VectorVal [IntegerVal 255,IntegerVal 20,IntegerVal 127,IntegerVal 0,IntegerVal 128,IntegerVal 127,IntegerVal 220,IntegerVal 255]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u8(UINT64_C(0x90ff7fffff7f37ff));
      arg2 = vcreate_u8(UINT64_C(0xc28000ff4a00005b));
      arg3 = vcreate_u8(UINT64_C(0xffdc7f80007f14ff));
      clear_neon_saturated();
      //  Expect: "result" = 52ff7f7fff7f375a
      result = vmls_u8(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u8(result), 0);
      exp = UINT64_C(0x52ff7f7fff7f375a);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_203() {

{
   {
      uint16x4_t arg1;
      uint16x4_t arg2;
      uint16x4_t arg3;
      uint16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"mls\", fnname = \"vmls_u16\", rettype = \"uint16x4_t\", argtypes = \"[uint16x4_t,uint16x4_t,uint16x4_t]\", vals = [VectorVal [IntegerVal 65535,IntegerVal 0,IntegerVal 65535,IntegerVal 0],VectorVal [IntegerVal 28278,IntegerVal 7384,IntegerVal 29744,IntegerVal 0],VectorVal [IntegerVal 0,IntegerVal 32767,IntegerVal 32767,IntegerVal 0]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u16(UINT64_C(0x0000ffff0000ffff));
      arg2 = vcreate_u16(UINT64_C(0x000074301cd86e76));
      arg3 = vcreate_u16(UINT64_C(0x00007fff7fff0000));
      clear_neon_saturated();
      //  Expect: "result" = 0000742f1cd8ffff
      result = vmls_u16(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u16(result), 0);
      exp = UINT64_C(0x0000742f1cd8ffff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_204() {

{
   {
      uint32x2_t arg1;
      uint32x2_t arg2;
      uint32x2_t arg3;
      uint32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"mls\", fnname = \"vmls_u32\", rettype = \"uint32x2_t\", argtypes = \"[uint32x2_t,uint32x2_t,uint32x2_t]\", vals = [VectorVal [IntegerVal 2147483647,IntegerVal 2147450880],VectorVal [IntegerVal 2147483648,IntegerVal 2147449605],VectorVal [IntegerVal 2147450880,IntegerVal 4294934528]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u32(UINT64_C(0x7fff80007fffffff));
      arg2 = vcreate_u32(UINT64_C(0x7fff7b0580000000));
      arg3 = vcreate_u32(UINT64_C(0xffff80007fff8000));
      clear_neon_saturated();
      //  Expect: "result" = 3d8200007fffffff
      result = vmls_u32(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u32(result), 0);
      exp = UINT64_C(0x3d8200007fffffff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_205() {

{
   {
      int8x16_t arg1;
      int8x16_t arg2;
      int8x16_t arg3;
      int8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"mls\", fnname = \"vmlsq_s8\", rettype = \"int8x16_t\", argtypes = \"[int8x16_t,int8x16_t,int8x16_t]\", vals = [VectorVal [IntegerVal 127,IntegerVal 89,IntegerVal 0,IntegerVal 127,IntegerVal 0,IntegerVal (-128),IntegerVal (-128),IntegerVal (-128),IntegerVal 0,IntegerVal 127,IntegerVal (-12),IntegerVal (-1),IntegerVal (-128),IntegerVal 127,IntegerVal (-1),IntegerVal (-128)],VectorVal [IntegerVal 0,IntegerVal (-128),IntegerVal 0,IntegerVal (-83),IntegerVal (-9),IntegerVal 0,IntegerVal (-1),IntegerVal 127,IntegerVal (-128),IntegerVal (-128),IntegerVal (-1),IntegerVal 0,IntegerVal 0,IntegerVal (-128),IntegerVal 55,IntegerVal 127],VectorVal [IntegerVal 121,IntegerVal (-4),IntegerVal (-128),IntegerVal (-1),IntegerVal 127,IntegerVal 0,IntegerVal (-110),IntegerVal 0,IntegerVal 127,IntegerVal (-98),IntegerVal (-1),IntegerVal 127,IntegerVal (-1),IntegerVal (-128),IntegerVal (-1),IntegerVal 0]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s8(vcreate_s8(UINT64_C(0x808080007f00597f)),
                         vcreate_s8(UINT64_C(0x80ff7f80fff47f00)));
      arg2 = vcombine_s8(vcreate_s8(UINT64_C(0x7fff00f7ad008000)),
                         vcreate_s8(UINT64_C(0x7f37800000ff8080)));
      arg3 = vcombine_s8(vcreate_s8(UINT64_C(0x0092007fff80fc79)),
                         vcreate_s8(UINT64_C(0x00ff80ff7fff9e7f)));
      clear_neon_saturated();
      //  Expect: "result" = 80367f80fff37f80801280772c00597f
      result = vmlsq_s8(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result), 0);
         exp = UINT64_C(0x801280772c00597f);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result), 1);
         exp = UINT64_C(0x80367f80fff37f80);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_206() {

{
   {
      int16x8_t arg1;
      int16x8_t arg2;
      int16x8_t arg3;
      int16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"mls\", fnname = \"vmlsq_s16\", rettype = \"int16x8_t\", argtypes = \"[int16x8_t,int16x8_t,int16x8_t]\", vals = [VectorVal [IntegerVal 32767,IntegerVal 32767,IntegerVal (-1),IntegerVal 0,IntegerVal 0,IntegerVal (-10476),IntegerVal (-32768),IntegerVal 0],VectorVal [IntegerVal (-1),IntegerVal 32767,IntegerVal 0,IntegerVal (-1),IntegerVal 32767,IntegerVal 0,IntegerVal (-32768),IntegerVal (-1)],VectorVal [IntegerVal (-1),IntegerVal 0,IntegerVal (-1),IntegerVal (-32768),IntegerVal 32767,IntegerVal (-32768),IntegerVal 0,IntegerVal 28649]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s16(vcreate_s16(UINT64_C(0x0000ffff7fff7fff)),
                          vcreate_s16(UINT64_C(0x00008000d7140000)));
      arg2 = vcombine_s16(vcreate_s16(UINT64_C(0xffff00007fffffff)),
                          vcreate_s16(UINT64_C(0xffff800000007fff)));
      arg3 = vcombine_s16(vcreate_s16(UINT64_C(0x8000ffff0000ffff)),
                          vcreate_s16(UINT64_C(0x6fe9000080007fff)));
      clear_neon_saturated();
      //  Expect: "result" = 6fe98000d714ffff8000ffff7fff7ffe
      result = vmlsq_s16(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 0);
         exp = UINT64_C(0x8000ffff7fff7ffe);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 1);
         exp = UINT64_C(0x6fe98000d714ffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_207() {

{
   {
      int32x4_t arg1;
      int32x4_t arg2;
      int32x4_t arg3;
      int32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"mls\", fnname = \"vmlsq_s32\", rettype = \"int32x4_t\", argtypes = \"[int32x4_t,int32x4_t,int32x4_t]\", vals = [VectorVal [IntegerVal 0,IntegerVal 32768,IntegerVal 2147418112,IntegerVal (-2147483648)],VectorVal [IntegerVal 1123385344,IntegerVal (-2147450881),IntegerVal 50955,IntegerVal 2147483647],VectorVal [IntegerVal 2147450880,IntegerVal 65535,IntegerVal 2147428142,IntegerVal (-2147450880)]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s32(vcreate_s32(UINT64_C(0x0000800000000000)),
                          vcreate_s32(UINT64_C(0x800000007fff0000)));
      arg2 = vcombine_s32(vcreate_s32(UINT64_C(0x80007fff42f58000)),
                          vcreate_s32(UINT64_C(0x7fffffff0000c70b)));
      arg3 = vcombine_s32(vcreate_s32(UINT64_C(0x0000ffff7fff8000)),
                          vcreate_s32(UINT64_C(0x800080007fff272e)));
      clear_neon_saturated();
      //  Expect: "result" = 00008000a8938f060001ffffc0000000
      result = vmlsq_s32(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 0);
         exp = UINT64_C(0x0001ffffc0000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 1);
         exp = UINT64_C(0x00008000a8938f06);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_208() {

{
   {
      uint8x16_t arg1;
      uint8x16_t arg2;
      uint8x16_t arg3;
      uint8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"mls\", fnname = \"vmlsq_u8\", rettype = \"uint8x16_t\", argtypes = \"[uint8x16_t,uint8x16_t,uint8x16_t]\", vals = [VectorVal [IntegerVal 0,IntegerVal 128,IntegerVal 0,IntegerVal 255,IntegerVal 128,IntegerVal 255,IntegerVal 255,IntegerVal 128,IntegerVal 127,IntegerVal 86,IntegerVal 90,IntegerVal 128,IntegerVal 255,IntegerVal 255,IntegerVal 28,IntegerVal 255],VectorVal [IntegerVal 0,IntegerVal 127,IntegerVal 203,IntegerVal 255,IntegerVal 195,IntegerVal 255,IntegerVal 0,IntegerVal 0,IntegerVal 127,IntegerVal 87,IntegerVal 128,IntegerVal 128,IntegerVal 0,IntegerVal 127,IntegerVal 0,IntegerVal 173],VectorVal [IntegerVal 255,IntegerVal 192,IntegerVal 232,IntegerVal 255,IntegerVal 128,IntegerVal 27,IntegerVal 5,IntegerVal 128,IntegerVal 127,IntegerVal 127,IntegerVal 128,IntegerVal 127,IntegerVal 0,IntegerVal 0,IntegerVal 0,IntegerVal 128]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u8(vcreate_u8(UINT64_C(0x80ffff80ff008000)),
                         vcreate_u8(UINT64_C(0xff1cffff805a567f)));
      arg2 = vcombine_u8(vcreate_u8(UINT64_C(0x0000ffc3ffcb7f00)),
                         vcreate_u8(UINT64_C(0xad007f008080577f)));
      arg3 = vcombine_u8(vcreate_u8(UINT64_C(0x80051b80ffe8c0ff)),
                         vcreate_u8(UINT64_C(0x800000007f807f7f)));
      clear_neon_saturated();
      //  Expect: "result" = 7f1cffff005a2d7e80ff1a00fe084000
      result = vmlsq_u8(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 0);
         exp = UINT64_C(0x80ff1a00fe084000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 1);
         exp = UINT64_C(0x7f1cffff005a2d7e);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_209() {

{
   {
      uint16x8_t arg1;
      uint16x8_t arg2;
      uint16x8_t arg3;
      uint16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"mls\", fnname = \"vmlsq_u16\", rettype = \"uint16x8_t\", argtypes = \"[uint16x8_t,uint16x8_t,uint16x8_t]\", vals = [VectorVal [IntegerVal 32767,IntegerVal 36530,IntegerVal 46534,IntegerVal 32768,IntegerVal 52360,IntegerVal 0,IntegerVal 54611,IntegerVal 32767],VectorVal [IntegerVal 32767,IntegerVal 54356,IntegerVal 15942,IntegerVal 46997,IntegerVal 32768,IntegerVal 19840,IntegerVal 32767,IntegerVal 642],VectorVal [IntegerVal 32768,IntegerVal 0,IntegerVal 65535,IntegerVal 65535,IntegerVal 32768,IntegerVal 32767,IntegerVal 32767,IntegerVal 65535]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u16(vcreate_u16(UINT64_C(0x8000b5c68eb27fff)),
                          vcreate_u16(UINT64_C(0x7fffd5530000cc88)));
      arg2 = vcombine_u16(vcreate_u16(UINT64_C(0xb7953e46d4547fff)),
                          vcreate_u16(UINT64_C(0x02827fff4d808000)));
      arg3 = vcombine_u16(vcreate_u16(UINT64_C(0xffffffff00008000)),
                          vcreate_u16(UINT64_C(0xffff7fff7fff8000)));
      clear_neon_saturated();
      //  Expect: "result" = 8281d5524d80cc883795f40c8eb2ffff
      result = vmlsq_u16(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 0);
         exp = UINT64_C(0x3795f40c8eb2ffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 1);
         exp = UINT64_C(0x8281d5524d80cc88);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_210() {

{
   {
      uint32x4_t arg1;
      uint32x4_t arg2;
      uint32x4_t arg3;
      uint32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"mls\", fnname = \"vmlsq_u32\", rettype = \"uint32x4_t\", argtypes = \"[uint32x4_t,uint32x4_t,uint32x4_t]\", vals = [VectorVal [IntegerVal 2147433242,IntegerVal 2147441038,IntegerVal 1437564928,IntegerVal 2147483647],VectorVal [IntegerVal 776667136,IntegerVal 0,IntegerVal 3945201663,IntegerVal 2147483648],VectorVal [IntegerVal 2147483648,IntegerVal 598343680,IntegerVal 4294934527,IntegerVal 2147524035]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u32(vcreate_u32(UINT64_C(0x7fff598e7fff3b1a)),
                          vcreate_u32(UINT64_C(0x7fffffff55af8000)));
      arg2 = vcombine_u32(vcreate_u32(UINT64_C(0x000000002e4b0000)),
                          vcreate_u32(UINT64_C(0x80000000eb26ffff)));
      arg3 = vcombine_u32(vcreate_u32(UINT64_C(0x23aa000080000000)),
                          vcreate_u32(UINT64_C(0x80009dc3ffff7fff)));
      clear_neon_saturated();
      //  Expect: "result" = ffffffffc0d5ffff7fff598e7fff3b1a
      result = vmlsq_u32(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 0);
         exp = UINT64_C(0x7fff598e7fff3b1a);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 1);
         exp = UINT64_C(0xffffffffc0d5ffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_211() {

{
   {
      float32x2_t arg1;
      float32x2_t arg2;
      float32x2_t arg3;
      float32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"mls\", fnname = \"vfms_f32\", rettype = \"float32x2_t\", argtypes = \"[float32x2_t,float32x2_t,float32x2_t]\", vals = [VectorVal [FloatVal 0.33316779136657715,FloatVal 0.795536994934082],VectorVal [FloatVal 3.146618604660034e-2,FloatVal 2.6081502437591553e-2],VectorVal [FloatVal 0.7430906295776367,FloatVal 0.7188999056816101]], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_f32(UINT64_C(0x3f4ba8503eaa94f8));
      arg2 = vcreate_f32(UINT64_C(0x3cd5a8e03d00e2b0));
      arg3 = vcreate_f32(UINT64_C(0x3f3809d33f3e3b30));
      clear_neon_saturated();
      //  Expect: "result" = 3f46db833e9e9c37
      result = vfms_f32(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result, 0);
         exp = ((float32_t) 0.3097855746746063);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result, 1);
         exp = ((float32_t) 0.7767869830131531);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
   }
}
}
void dotests_212() {

{
   {
      float32x4_t arg1;
      float32x4_t arg2;
      float32x4_t arg3;
      float32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"mls\", fnname = \"vfmsq_f32\", rettype = \"float32x4_t\", argtypes = \"[float32x4_t,float32x4_t,float32x4_t]\", vals = [VectorVal [FloatVal 0.7210066318511963,FloatVal 0.2663896083831787,FloatVal 0.7976276278495789,FloatVal 0.6981443762779236],VectorVal [FloatVal 0.8121473789215088,FloatVal 0.834670901298523,FloatVal 0.5449929237365723,FloatVal 0.5822281241416931],VectorVal [FloatVal 0.6892375946044922,FloatVal 0.39572393894195557,FloatVal 1.2957453727722168e-3,FloatVal 0.6025665998458862]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_f32(vcreate_f32(UINT64_C(0x3e8864383f3893e4)),
                          vcreate_f32(UINT64_C(0x3f32b9973f4c3153)));
      arg2 = vcombine_f32(vcreate_f32(UINT64_C(0x3f55acfe3f4fe8e4)),
                          vcreate_f32(UINT64_C(0x3f150ce73f0b84a8)));
      arg3 = vcombine_f32(vcreate_f32(UINT64_C(0x3eca9c543f3071e0)),
                          vcreate_f32(UINT64_C(0x3f1a41ce3aa9d600)));
      clear_neon_saturated();
      //  Expect: "result" = 3eb1d3083f4c030bbd82e3103e251d2e
      result = vfmsq_f32(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 0);
         exp = ((float32_t) 0.16124412417411804);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 1);
         exp = ((float32_t) -6.390964984893799e-2);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 2);
         exp = ((float32_t) 0.79692143201828);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 2 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 3);
         exp = ((float32_t) 0.34731316566467285);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 3 ", exp, got);
            }
      }
   }
}
}
void dotests_213() {

{
   {
      float64x2_t arg1;
      float64x2_t arg2;
      float64x2_t arg3;
      float64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"mls\", fnname = \"vfmsq_f64\", rettype = \"float64x2_t\", argtypes = \"[float64x2_t,float64x2_t,float64x2_t]\", vals = [VectorVal [FloatVal 0.7341674092947582,FloatVal 0.3120734761337982],VectorVal [FloatVal 0.7648043957063155,FloatVal 0.27073800303263795],VectorVal [FloatVal 0.4671120548625505,FloatVal 0.3273242128594823]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_f64(vcreate_f64(UINT64_C(0x3fe77e4ca696b897)),
                          vcreate_f64(UINT64_C(0x3fd3f903077c6594)));
      arg2 = vcombine_f64(vcreate_f64(UINT64_C(0x3fe87947116ca950)),
                          vcreate_f64(UINT64_C(0x3fd153c57d33cf52)));
      arg3 = vcombine_f64(vcreate_f64(UINT64_C(0x3fdde529f5ccedc4)),
                          vcreate_f64(UINT64_C(0x3fd4f2e1415ae826)));
      clear_neon_saturated();
      //  Expect: "result" = 3fcc9a2722cd96fb3fd81f6ce96df4b4
      result = vfmsq_f64(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float64_t got;
         float64_t exp;
         got = vgetq_lane_f64(result, 0);
         exp = 0.37691805644847;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float64_t got;
         float64_t exp;
         got = vgetq_lane_f64(result, 1);
         exp = 0.22345437239999186;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
   }
}
}
void dotests_214() {

{
   {
      float64x1_t arg1;
      float64x1_t arg2;
      float64x1_t arg3;
      float64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"mls\", fnname = \"vfms_f64\", rettype = \"float64x1_t\", argtypes = \"[float64x1_t,float64x1_t,float64x1_t]\", vals = [VectorVal [FloatVal 2.329701079495594e-2],VectorVal [FloatVal 0.7389985214494788],VectorVal [FloatVal 0.35260261051980024]], start_saturated = False}";
      int reported = 0;
      float64_t got;
      float64_t exp;
      arg1 = vcreate_f64(UINT64_C(0x3f97db2bedd5e880));
      arg2 = vcreate_f64(UINT64_C(0x3fe7a5e03a2d5f28));
      arg3 = vcreate_f64(UINT64_C(0x3fd6910a8a2aac52));
      clear_neon_saturated();
      //  Expect: "result" = bfce5f0da634c564
      result = vfms_f64(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_f64(result, 0);
      exp = -0.23727579703840285;
      if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
         }
   }
}
}
void dotests_215() {

{
   {
      float32x2_t arg1;
      float32x2_t arg2;
      float32x2_t arg3;
      float32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"mls\", fnname = \"vmls_f32\", rettype = \"float32x2_t\", argtypes = \"[float32x2_t,float32x2_t,float32x2_t]\", vals = [VectorVal [FloatVal 0.11067205667495728,FloatVal 0.2678745985031128],VectorVal [FloatVal 0.6423867344856262,FloatVal 0.7507759928703308],VectorVal [FloatVal 0.26666808128356934,FloatVal 0.2080388069152832]], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_f32(UINT64_C(0x3e8926dc3de2a808));
      arg2 = vcreate_f32(UINT64_C(0x3f4032db3f247375));
      arg3 = vcreate_f32(UINT64_C(0x3e5508203e8888b8));
      clear_neon_saturated();
      //  Expect: "result" = 3de4ba9cbd78593e
      result = vmls_f32(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result, 0);
         exp = ((float32_t) -6.063198298215866e-2);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result, 1);
         exp = ((float32_t) 0.11168405413627625);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
   }
}
}
void dotests_216() {

{
   {
      float32x4_t arg1;
      float32x4_t arg2;
      float32x4_t arg3;
      float32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"mls\", fnname = \"vmlsq_f32\", rettype = \"float32x4_t\", argtypes = \"[float32x4_t,float32x4_t,float32x4_t]\", vals = [VectorVal [FloatVal 0.8864086866378784,FloatVal 0.36815696954727173,FloatVal 0.4579457640647888,FloatVal 0.6729732155799866],VectorVal [FloatVal 0.33614522218704224,FloatVal 0.7089780569076538,FloatVal 1.621156930923462e-2,FloatVal 0.7321020364761353],VectorVal [FloatVal 0.6063637137413025,FloatVal 9.446007013320923e-2,FloatVal 0.7341058254241943,FloatVal 0.6447949409484863]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_f32(vcreate_f32(UINT64_C(0x3ebc7f123f62ebae)),
                          vcreate_f32(UINT64_C(0x3f2c47f93eea77de)));
      arg2 = vcombine_f32(vcreate_f32(UINT64_C(0x3f357f963eac1b3a)),
                          vcreate_f32(UINT64_C(0x3f3b6b0a3c84ce20)));
      arg3 = vcombine_f32(vcreate_f32(UINT64_C(0x3dc174483f1b3aa7)),
                          vcreate_f32(UINT64_C(0x3f2511483f3bee5c)));
      clear_neon_saturated();
      //  Expect: "result" = 3e4dbd533ee45ffa3e9a352a3f2ebdb9
      result = vmlsq_f32(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 0);
         exp = ((float32_t) 0.682582437992096);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 1);
         exp = ((float32_t) 0.30118685960769653);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 2);
         exp = ((float32_t) 0.4460447430610657);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 2 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 3);
         exp = ((float32_t) 0.20091752707958221);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 3 ", exp, got);
            }
      }
   }
}
}
void dotests_217() {

{
   {
      float64x2_t arg1;
      float64x2_t arg2;
      float64x2_t arg3;
      float64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"mls\", fnname = \"vmlsq_f64\", rettype = \"float64x2_t\", argtypes = \"[float64x2_t,float64x2_t,float64x2_t]\", vals = [VectorVal [FloatVal 0.7169973526218792,FloatVal 0.24968247703092805],VectorVal [FloatVal 0.8092840452447038,FloatVal 0.9377388873415169],VectorVal [FloatVal 0.803108926686415,FloatVal 0.36502161541764944]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_f64(vcreate_f64(UINT64_C(0x3fe6f1a46e9a8baf)),
                          vcreate_f64(UINT64_C(0x3fcff5986c9db5b0)));
      arg2 = vcombine_f64(vcreate_f64(UINT64_C(0x3fe9e5a7a77004cf)),
                          vcreate_f64(UINT64_C(0x3fee01f4fbaa373e)));
      arg3 = vcombine_f64(vcreate_f64(UINT64_C(0x3fe9b3117de7cd53)),
                          vcreate_f64(UINT64_C(0x3fd75c839f23523a)));
      clear_neon_saturated();
      //  Expect: "result" = bfb7b573b09313f83fb12a7550a56be0
      result = vmlsq_f64(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float64_t got;
         float64_t exp;
         got = vgetq_lane_f64(result, 0);
         exp = 6.705411166096509e-2;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float64_t got;
         float64_t exp;
         got = vgetq_lane_f64(result, 1);
         exp = -9.261248646642162e-2;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
   }
}
}
void dotests_218() {

{
   {
      float64x1_t arg1;
      float64x1_t arg2;
      float64x1_t arg3;
      float64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"mls\", fnname = \"vmls_f64\", rettype = \"float64x1_t\", argtypes = \"[float64x1_t,float64x1_t,float64x1_t]\", vals = [VectorVal [FloatVal 0.8612911220451575],VectorVal [FloatVal 3.6827639370720644e-2],VectorVal [FloatVal 1.699983357345336e-2]], start_saturated = False}";
      int reported = 0;
      float64_t got;
      float64_t exp;
      arg1 = vcreate_f64(UINT64_C(0x3feb8fb266309c6f));
      arg2 = vcreate_f64(UINT64_C(0x3fa2db12855f4c10));
      arg3 = vcreate_f64(UINT64_C(0x3f91686784f11340));
      clear_neon_saturated();
      //  Expect: "result" = 3feb8a9172c759b8
      result = vmls_f64(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_f64(result, 0);
      exp = 0.860665058304952;
      if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
         }
   }
}
}
void dotests_219() {

{
   {
      int16x8_t arg1;
      int8x8_t arg2;
      int8x8_t arg3;
      int16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"mls\", fnname = \"vmlsl_s8\", rettype = \"int16x8_t\", argtypes = \"[int16x8_t,int8x8_t,int8x8_t]\", vals = [VectorVal [IntegerVal 32767,IntegerVal 0,IntegerVal (-1),IntegerVal 0,IntegerVal (-32768),IntegerVal (-32768),IntegerVal 0,IntegerVal (-14669)],VectorVal [IntegerVal 127,IntegerVal (-1),IntegerVal 127,IntegerVal (-1),IntegerVal (-128),IntegerVal 0,IntegerVal (-1),IntegerVal 127],VectorVal [IntegerVal (-128),IntegerVal (-1),IntegerVal (-1),IntegerVal (-122),IntegerVal (-128),IntegerVal 0,IntegerVal (-1),IntegerVal (-128)]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s16(vcreate_s16(UINT64_C(0x0000ffff00007fff)),
                          vcreate_s16(UINT64_C(0xc6b3000080008000)));
      arg2 = vcreate_s8(UINT64_C(0x7fff0080ff7fff7f));
      arg3 = vcreate_s8(UINT64_C(0x80ff008086ffff80));
      clear_neon_saturated();
      //  Expect: "result" = 0633ffff80004000ff86007effffbf7f
      result = vmlsl_s8(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 0);
         exp = UINT64_C(0xff86007effffbf7f);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 1);
         exp = UINT64_C(0x0633ffff80004000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_220() {

{
   {
      int32x4_t arg1;
      int16x4_t arg2;
      int16x4_t arg3;
      int32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"mls\", fnname = \"vmlsl_s16\", rettype = \"int32x4_t\", argtypes = \"[int32x4_t,int16x4_t,int16x4_t]\", vals = [VectorVal [IntegerVal 65535,IntegerVal 2147450879,IntegerVal (-1877082113),IntegerVal 732758015],VectorVal [IntegerVal 32767,IntegerVal (-1),IntegerVal 0,IntegerVal (-32768)],VectorVal [IntegerVal (-1),IntegerVal 32767,IntegerVal (-32768),IntegerVal (-30669)]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s32(vcreate_s32(UINT64_C(0x7fff7fff0000ffff)),
                          vcreate_s32(UINT64_C(0x2bacffff901dffff)));
      arg2 = vcreate_s16(UINT64_C(0x80000000ffff7fff));
      arg3 = vcreate_s16(UINT64_C(0x883380007fffffff));
      clear_neon_saturated();
      //  Expect: "result" = efc67fff901dffff7ffffffe00017ffe
      result = vmlsl_s16(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 0);
         exp = UINT64_C(0x7ffffffe00017ffe);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 1);
         exp = UINT64_C(0xefc67fff901dffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_221() {

{
   {
      int64x2_t arg1;
      int32x2_t arg2;
      int32x2_t arg3;
      int64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"mls\", fnname = \"vmlsl_s32\", rettype = \"int64x2_t\", argtypes = \"[int64x2_t,int32x2_t,int32x2_t]\", vals = [VectorVal [IntegerVal (-9223090564025557946),IntegerVal (-9223372034639331328)],VectorVal [IntegerVal 65535,IntegerVal 2147450879],VectorVal [IntegerVal 2147450880,IntegerVal (-2147418113)]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s64(vcreate_s64(UINT64_C(0x8000ffff7fffdc46)),
                          vcreate_s64(UINT64_C(0x80000000840d0000)));
      arg2 = vcreate_s32(UINT64_C(0x7fff7fff0000ffff));
      arg3 = vcreate_s32(UINT64_C(0x8000ffff7fff8000));
      clear_neon_saturated();
      //  Expect: "result" = bfff4001040d7fff800080007fff5c46
      result = vmlsl_s32(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 0);
         exp = UINT64_C(0x800080007fff5c46);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 1);
         exp = UINT64_C(0xbfff4001040d7fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_222() {

{
   {
      uint16x8_t arg1;
      uint8x8_t arg2;
      uint8x8_t arg3;
      uint16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"mls\", fnname = \"vmlsl_u8\", rettype = \"uint16x8_t\", argtypes = \"[uint16x8_t,uint8x8_t,uint8x8_t]\", vals = [VectorVal [IntegerVal 32768,IntegerVal 0,IntegerVal 32768,IntegerVal 0,IntegerVal 55880,IntegerVal 30542,IntegerVal 32768,IntegerVal 32768],VectorVal [IntegerVal 145,IntegerVal 0,IntegerVal 127,IntegerVal 255,IntegerVal 255,IntegerVal 127,IntegerVal 128,IntegerVal 242],VectorVal [IntegerVal 128,IntegerVal 212,IntegerVal 128,IntegerVal 255,IntegerVal 255,IntegerVal 141,IntegerVal 127,IntegerVal 0]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u16(vcreate_u16(UINT64_C(0x0000800000008000)),
                          vcreate_u16(UINT64_C(0x80008000774eda48)));
      arg2 = vcreate_u8(UINT64_C(0xf2807fffff7f0091));
      arg3 = vcreate_u8(UINT64_C(0x007f8dffff80d480));
      clear_neon_saturated();
      //  Expect: "result" = 80004080315bdc4701ff408000003780
      result = vmlsl_u8(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 0);
         exp = UINT64_C(0x01ff408000003780);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 1);
         exp = UINT64_C(0x80004080315bdc47);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_223() {

{
   {
      uint32x4_t arg1;
      uint16x4_t arg2;
      uint16x4_t arg3;
      uint32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"mls\", fnname = \"vmlsl_u16\", rettype = \"uint32x4_t\", argtypes = \"[uint32x4_t,uint16x4_t,uint16x4_t]\", vals = [VectorVal [IntegerVal 2147520270,IntegerVal 2147450880,IntegerVal 2147450879,IntegerVal 2986],VectorVal [IntegerVal 0,IntegerVal 0,IntegerVal 61793,IntegerVal 32767],VectorVal [IntegerVal 65535,IntegerVal 32768,IntegerVal 32767,IntegerVal 55479]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u32(vcreate_u32(UINT64_C(0x7fff800080008f0e)),
                          vcreate_u32(UINT64_C(0x00000baa7fff7fff)));
      arg2 = vcreate_u16(UINT64_C(0x7ffff16100000000));
      arg3 = vcreate_u16(UINT64_C(0xd8b77fff8000ffff));
      clear_neon_saturated();
      //  Expect: "result" = 93a56461074ff1607fff800080008f0e
      result = vmlsl_u16(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 0);
         exp = UINT64_C(0x7fff800080008f0e);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 1);
         exp = UINT64_C(0x93a56461074ff160);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_224() {

{
   {
      uint64x2_t arg1;
      uint32x2_t arg2;
      uint32x2_t arg3;
      uint64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"mls\", fnname = \"vmlsl_u32\", rettype = \"uint64x2_t\", argtypes = \"[uint64x2_t,uint32x2_t,uint32x2_t]\", vals = [VectorVal [IntegerVal 11069847884076711936,IntegerVal 9223512770251327165],VectorVal [IntegerVal 873299967,IntegerVal 2147516416],VectorVal [IntegerVal 4294966220,IntegerVal 357564415]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u64(vcreate_u64(UINT64_C(0x99a0000000008000)),
                          vcreate_u64(UINT64_C(0x80007fff0c1c06bd)));
      arg2 = vcreate_u32(UINT64_C(0x80008000340d7fff));
      arg3 = vcreate_u32(UINT64_C(0x154ffffffffffbcc));
      clear_neon_saturated();
      //  Expect: "result" = 755875578c1c86bd659280dbc8be7bcc
      result = vmlsl_u32(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 0);
         exp = UINT64_C(0x659280dbc8be7bcc);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 1);
         exp = UINT64_C(0x755875578c1c86bd);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_225() {

{
   {
      int16x8_t arg1;
      int8x16_t arg2;
      int8x16_t arg3;
      int16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"mls\", fnname = \"vmlsl_high_s8\", rettype = \"int16x8_t\", argtypes = \"[int16x8_t,int8x16_t,int8x16_t]\", vals = [VectorVal [IntegerVal 10413,IntegerVal (-1),IntegerVal (-21760),IntegerVal 0,IntegerVal 0,IntegerVal (-7589),IntegerVal 32767,IntegerVal 0],VectorVal [IntegerVal (-30),IntegerVal 127,IntegerVal (-86),IntegerVal 0,IntegerVal (-1),IntegerVal 0,IntegerVal (-1),IntegerVal (-128),IntegerVal 127,IntegerVal (-1),IntegerVal 0,IntegerVal 127,IntegerVal 0,IntegerVal 0,IntegerVal (-1),IntegerVal 49],VectorVal [IntegerVal 127,IntegerVal 127,IntegerVal 127,IntegerVal (-1),IntegerVal (-128),IntegerVal (-1),IntegerVal 127,IntegerVal (-1),IntegerVal 0,IntegerVal (-128),IntegerVal (-128),IntegerVal (-82),IntegerVal 0,IntegerVal (-1),IntegerVal 33,IntegerVal 127]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s16(vcreate_s16(UINT64_C(0x0000ab00ffff28ad)),
                          vcreate_s16(UINT64_C(0x00007fffe25b0000)));
      arg2 = vcombine_s8(vcreate_s8(UINT64_C(0x80ff00ff00aa7fe2)),
                         vcreate_s8(UINT64_C(0x31ff00007f00ff7f)));
      arg3 = vcombine_s8(vcreate_s8(UINT64_C(0xff7fff80ff7f7f7f)),
                         vcreate_s8(UINT64_C(0x7f21ff00ae808000)));
      clear_neon_saturated();
      //  Expect: "result" = e7b18020e25b000028aeab00ff7f28ad
      result = vmlsl_high_s8(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 0);
         exp = UINT64_C(0x28aeab00ff7f28ad);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 1);
         exp = UINT64_C(0xe7b18020e25b0000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_226() {

{
   {
      int32x4_t arg1;
      int16x8_t arg2;
      int16x8_t arg3;
      int32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"mls\", fnname = \"vmlsl_high_s16\", rettype = \"int32x4_t\", argtypes = \"[int32x4_t,int16x8_t,int16x8_t]\", vals = [VectorVal [IntegerVal (-2104098817),IntegerVal 1339588608,IntegerVal 727711743,IntegerVal (-1)],VectorVal [IntegerVal (-32768),IntegerVal (-32768),IntegerVal 1549,IntegerVal 0,IntegerVal (-1),IntegerVal (-1),IntegerVal (-1),IntegerVal (-9723)],VectorVal [IntegerVal (-32768),IntegerVal 0,IntegerVal (-1),IntegerVal (-1),IntegerVal (-1),IntegerVal (-32768),IntegerVal (-32768),IntegerVal (-1)]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s32(vcreate_s32(UINT64_C(0x4fd880008295ffff)),
                          vcreate_s32(UINT64_C(0xffffffff2b5fffff)));
      arg2 = vcombine_s16(vcreate_s16(UINT64_C(0x0000060d80008000)),
                          vcreate_s16(UINT64_C(0xda05ffffffffffff)));
      arg3 = vcombine_s16(vcreate_s16(UINT64_C(0xffffffff00008000)),
                          vcreate_s16(UINT64_C(0xffff80008000ffff)));
      clear_neon_saturated();
      //  Expect: "result" = ffffda042b5f7fff4fd800008295fffe
      result = vmlsl_high_s16(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 0);
         exp = UINT64_C(0x4fd800008295fffe);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 1);
         exp = UINT64_C(0xffffda042b5f7fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_227() {

{
   {
      int64x2_t arg1;
      int32x4_t arg2;
      int32x4_t arg3;
      int64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"mls\", fnname = \"vmlsl_high_s32\", rettype = \"int64x2_t\", argtypes = \"[int64x2_t,int32x4_t,int32x4_t]\", vals = [VectorVal [IntegerVal 65535,IntegerVal (-9223231303661355009)],VectorVal [IntegerVal 50004,IntegerVal (-303895113),IntegerVal (-2147483648),IntegerVal (-1973485568)],VectorVal [IntegerVal 2147474075,IntegerVal 22295,IntegerVal 65535,IntegerVal (-65536)]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s64(vcreate_s64(UINT64_C(0x000000000000ffff)),
                          vcreate_s64(UINT64_C(0x80007fff00007fff)));
      arg2 = vcombine_s32(vcreate_s32(UINT64_C(0xede2edb70000c354)),
                          vcreate_s32(UINT64_C(0x8a5f000080000000)));
      arg3 = vcombine_s32(vcreate_s32(UINT64_C(0x000057177fffda9b)),
                          vcreate_s32(UINT64_C(0xffff00000000ffff)));
      clear_neon_saturated();
      //  Expect: "result" = 80000a5e00007fff00007fff8000ffff
      result = vmlsl_high_s32(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 0);
         exp = UINT64_C(0x00007fff8000ffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 1);
         exp = UINT64_C(0x80000a5e00007fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_228() {

{
   {
      uint16x8_t arg1;
      uint8x16_t arg2;
      uint8x16_t arg3;
      uint16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"mls\", fnname = \"vmlsl_high_u8\", rettype = \"uint16x8_t\", argtypes = \"[uint16x8_t,uint8x16_t,uint8x16_t]\", vals = [VectorVal [IntegerVal 65535,IntegerVal 32768,IntegerVal 32768,IntegerVal 65535,IntegerVal 44419,IntegerVal 32768,IntegerVal 65535,IntegerVal 0],VectorVal [IntegerVal 0,IntegerVal 255,IntegerVal 140,IntegerVal 0,IntegerVal 128,IntegerVal 0,IntegerVal 69,IntegerVal 128,IntegerVal 255,IntegerVal 88,IntegerVal 163,IntegerVal 112,IntegerVal 128,IntegerVal 127,IntegerVal 127,IntegerVal 255],VectorVal [IntegerVal 255,IntegerVal 127,IntegerVal 255,IntegerVal 0,IntegerVal 128,IntegerVal 128,IntegerVal 255,IntegerVal 127,IntegerVal 223,IntegerVal 128,IntegerVal 0,IntegerVal 0,IntegerVal 116,IntegerVal 127,IntegerVal 10,IntegerVal 253]], start_saturated = True}";
      int reported = 0;
      arg1 = vcombine_u16(vcreate_u16(UINT64_C(0xffff80008000ffff)),
                          vcreate_u16(UINT64_C(0x0000ffff8000ad83)));
      arg2 = vcombine_u8(vcreate_u8(UINT64_C(0x80450080008cff00)),
                         vcreate_u8(UINT64_C(0xff7f7f8070a358ff)));
      arg3 = vcombine_u8(vcreate_u8(UINT64_C(0x7fff808000ff7fff)),
                         vcreate_u8(UINT64_C(0xfd0a7f74000080df)));
      set_neon_saturated();
      //  Expect: "result" = 03fdfb0940ff7383ffff8000540021de
      result = vmlsl_high_u8(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 0);
         exp = UINT64_C(0xffff8000540021de);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 1);
         exp = UINT64_C(0x03fdfb0940ff7383);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_229() {

{
   {
      uint32x4_t arg1;
      uint16x8_t arg2;
      uint16x8_t arg3;
      uint32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"mls\", fnname = \"vmlsl_high_u16\", rettype = \"uint32x4_t\", argtypes = \"[uint32x4_t,uint16x8_t,uint16x8_t]\", vals = [VectorVal [IntegerVal 2147549183,IntegerVal 359202816,IntegerVal 2147498161,IntegerVal 2147483647],VectorVal [IntegerVal 32768,IntegerVal 65535,IntegerVal 32768,IntegerVal 65535,IntegerVal 32767,IntegerVal 32767,IntegerVal 32767,IntegerVal 0],VectorVal [IntegerVal 0,IntegerVal 32768,IntegerVal 65535,IntegerVal 12430,IntegerVal 65535,IntegerVal 65535,IntegerVal 32767,IntegerVal 32767]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u32(vcreate_u32(UINT64_C(0x156900008000ffff)),
                          vcreate_u32(UINT64_C(0x7fffffff800038b1)));
      arg2 = vcombine_u16(vcreate_u16(UINT64_C(0xffff8000ffff8000)),
                          vcreate_u16(UINT64_C(0x00007fff7fff7fff)));
      arg3 = vcombine_u16(vcreate_u16(UINT64_C(0x308effff80000000)),
                          vcreate_u16(UINT64_C(0x7fff7fffffffffff)));
      clear_neon_saturated();
      //  Expect: "result" = 7fffffff400138b0956a7fff00027ffe
      result = vmlsl_high_u16(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 0);
         exp = UINT64_C(0x956a7fff00027ffe);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 1);
         exp = UINT64_C(0x7fffffff400138b0);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_230() {

{
   {
      uint64x2_t arg1;
      uint32x4_t arg2;
      uint32x4_t arg3;
      uint64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"mls\", fnname = \"vmlsl_high_u32\", rettype = \"uint64x2_t\", argtypes = \"[uint64x2_t,uint32x4_t,uint32x4_t]\", vals = [VectorVal [IntegerVal 9223372041149743103,IntegerVal 18446603338368692602],VectorVal [IntegerVal 4294958711,IntegerVal 2147450879,IntegerVal 2147454329,IntegerVal 2147467487],VectorVal [IntegerVal 2147532222,IntegerVal 2147516416,IntegerVal 2147418112,IntegerVal 2147418112]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u64(vcreate_u64(UINT64_C(0x80000000ffffffff)),
                          vcreate_u64(UINT64_C(0xffff80008000317a)));
      arg2 = vcombine_u32(vcreate_u32(UINT64_C(0x7fff7fffffffde77)),
                          vcreate_u32(UINT64_C(0x7fffc0df7fff8d79)));
      arg3 = vcombine_u32(vcreate_u32(UINT64_C(0x800080008000bdbe)),
                          vcreate_u32(UINT64_C(0x7fff00007fff0000)));
      clear_neon_saturated();
      //  Expect: "result" = c0001f90c0df317a4000b9440d78ffff
      result = vmlsl_high_u32(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 0);
         exp = UINT64_C(0x4000b9440d78ffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 1);
         exp = UINT64_C(0xc0001f90c0df317a);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_231() {

{
   {
      int16x4_t arg1;
      int16x4_t arg2;
      int16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"qdmlh\", fnname = \"vqdmulh_s16\", rettype = \"int16x4_t\", argtypes = \"[int16x4_t,int16x4_t]\", vals = [VectorVal [IntegerVal (-1),IntegerVal 0,IntegerVal (-26286),IntegerVal 2005],VectorVal [IntegerVal 0,IntegerVal 32767,IntegerVal 0,IntegerVal (-1)]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s16(UINT64_C(0x07d599520000ffff));
      arg2 = vcreate_s16(UINT64_C(0xffff00007fff0000));
      clear_neon_saturated();
      //  Expect: "result" = ffff000000000000
      result = vqdmulh_s16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s16(result), 0);
      exp = UINT64_C(0xffff000000000000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_232() {

{
   {
      int32x2_t arg1;
      int32x2_t arg2;
      int32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"qdmlh\", fnname = \"vqdmulh_s32\", rettype = \"int32x2_t\", argtypes = \"[int32x2_t,int32x2_t]\", vals = [VectorVal [IntegerVal (-529268736),IntegerVal (-32769)],VectorVal [IntegerVal 2147483647,IntegerVal (-32768)]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s32(UINT64_C(0xffff7fffe0740000));
      arg2 = vcreate_s32(UINT64_C(0xffff80007fffffff));
      clear_neon_saturated();
      //  Expect: "result" = 00000000e0740000
      result = vqdmulh_s32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s32(result), 0);
      exp = UINT64_C(0x00000000e0740000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_233() {

{
   {
      int16x8_t arg1;
      int16x8_t arg2;
      int16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"qdmlh\", fnname = \"vqdmulhq_s16\", rettype = \"int16x8_t\", argtypes = \"[int16x8_t,int16x8_t]\", vals = [VectorVal [IntegerVal 23555,IntegerVal 32767,IntegerVal (-32768),IntegerVal 32767,IntegerVal 0,IntegerVal 0,IntegerVal 32767,IntegerVal (-19653)],VectorVal [IntegerVal (-22270),IntegerVal 0,IntegerVal 0,IntegerVal 4603,IntegerVal (-1),IntegerVal (-28560),IntegerVal 0,IntegerVal 21337]], start_saturated = True}";
      int reported = 0;
      arg1 = vcombine_s16(vcreate_s16(UINT64_C(0x7fff80007fff5c03)),
                          vcreate_s16(UINT64_C(0xb33b7fff00000000)));
      arg2 = vcombine_s16(vcreate_s16(UINT64_C(0x11fb00000000a902)),
                          vcreate_s16(UINT64_C(0x535900009070ffff)));
      set_neon_saturated();
      //  Expect: "result" = ce0200000000000011fa00000000c177
      result = vqdmulhq_s16(arg1, arg2);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 0);
         exp = UINT64_C(0x11fa00000000c177);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 1);
         exp = UINT64_C(0xce02000000000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_234() {

{
   {
      int32x4_t arg1;
      int32x4_t arg2;
      int32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"qdmlh\", fnname = \"vqdmulhq_s32\", rettype = \"int32x4_t\", argtypes = \"[int32x4_t,int32x4_t]\", vals = [VectorVal [IntegerVal 3351,IntegerVal 32768,IntegerVal (-32769),IntegerVal 32768],VectorVal [IntegerVal (-2147450881),IntegerVal (-1489400985),IntegerVal 32767,IntegerVal 2147480987]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s32(vcreate_s32(UINT64_C(0x0000800000000d17)),
                          vcreate_s32(UINT64_C(0x00008000ffff7fff)));
      arg2 = vcombine_s32(vcreate_s32(UINT64_C(0xa7398b6780007fff)),
                          vcreate_s32(UINT64_C(0x7ffff59b00007fff)));
      clear_neon_saturated();
      //  Expect: "result" = 00007fffffffffffffffa739fffff2e9
      result = vqdmulhq_s32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 0);
         exp = UINT64_C(0xffffa739fffff2e9);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 1);
         exp = UINT64_C(0x00007fffffffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_235() {

{
   {
      int16_t arg1;
      int16_t arg2;
      int16_t result;
      char* str1 = "ReproInfo2 {semantics = \"qdmlh\", fnname = \"vqdmulhh_s16\", rettype = \"int16_t\", argtypes = \"[int16_t,int16_t]\", vals = [IntegerVal 0,IntegerVal 18756], start_saturated = False}";
      int reported = 0;
      int16_t got;
      int16_t exp;
      arg1 = 0;
      arg2 = 18756;
      clear_neon_saturated();
      //  Expect: "result" = 0000
      result = vqdmulhh_s16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = 0;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIi16 " Got: %" PRIi16 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_236() {

{
   {
      int32_t arg1;
      int32_t arg2;
      int32_t result;
      char* str1 = "ReproInfo2 {semantics = \"qdmlh\", fnname = \"vqdmulhs_s32\", rettype = \"int32_t\", argtypes = \"[int32_t,int32_t]\", vals = [IntegerVal (-32769),IntegerVal (-1)], start_saturated = False}";
      int reported = 0;
      int32_t got;
      int32_t exp;
      arg1 = -32769;
      arg2 = -1;
      clear_neon_saturated();
      //  Expect: "result" = 00000000
      result = vqdmulhs_s32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = 0;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIi32 " Got: %" PRIi32 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_237() {

{
   {
      int16x4_t arg1;
      int16x4_t arg2;
      int16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"qrdmlh\", fnname = \"vqrdmulh_s16\", rettype = \"int16x4_t\", argtypes = \"[int16x4_t,int16x4_t]\", vals = [VectorVal [IntegerVal (-32768),IntegerVal (-32181),IntegerVal 32767,IntegerVal 32767],VectorVal [IntegerVal (-1),IntegerVal 0,IntegerVal 32767,IntegerVal 0]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s16(UINT64_C(0x7fff7fff824b8000));
      arg2 = vcreate_s16(UINT64_C(0x00007fff0000ffff));
      clear_neon_saturated();
      //  Expect: "result" = 00007ffe00000001
      result = vqrdmulh_s16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s16(result), 0);
      exp = UINT64_C(0x00007ffe00000001);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_238() {

{
   {
      int32x2_t arg1;
      int32x2_t arg2;
      int32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"qrdmlh\", fnname = \"vqrdmulh_s32\", rettype = \"int32x2_t\", argtypes = \"[int32x2_t,int32x2_t]\", vals = [VectorVal [IntegerVal 2147418112,IntegerVal 2147448068],VectorVal [IntegerVal (-2147450880),IntegerVal 2147450880]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s32(UINT64_C(0x7fff75047fff0000));
      arg2 = vcreate_s32(UINT64_C(0x7fff800080008000));
      clear_neon_saturated();
      //  Expect: "result" = 7ffef50580017fff
      result = vqrdmulh_s32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s32(result), 0);
      exp = UINT64_C(0x7ffef50580017fff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_239() {

{
   {
      int16x8_t arg1;
      int16x8_t arg2;
      int16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"qrdmlh\", fnname = \"vqrdmulhq_s16\", rettype = \"int16x8_t\", argtypes = \"[int16x8_t,int16x8_t]\", vals = [VectorVal [IntegerVal (-32768),IntegerVal (-1),IntegerVal (-32768),IntegerVal 0,IntegerVal 4585,IntegerVal 21514,IntegerVal (-1),IntegerVal (-32768)],VectorVal [IntegerVal (-1),IntegerVal 32767,IntegerVal 31768,IntegerVal 0,IntegerVal 0,IntegerVal (-1),IntegerVal (-30435),IntegerVal 32767]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s16(vcreate_s16(UINT64_C(0x00008000ffff8000)),
                          vcreate_s16(UINT64_C(0x8000ffff540a11e9)));
      arg2 = vcombine_s16(vcreate_s16(UINT64_C(0x00007c187fffffff)),
                          vcreate_s16(UINT64_C(0x7fff891dffff0000)));
      clear_neon_saturated();
      //  Expect: "result" = 80010001ffff0000000083e8ffff0001
      result = vqrdmulhq_s16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 0);
         exp = UINT64_C(0x000083e8ffff0001);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 1);
         exp = UINT64_C(0x80010001ffff0000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_240() {

{
   {
      int32x4_t arg1;
      int32x4_t arg2;
      int32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"qrdmlh\", fnname = \"vqrdmulhq_s32\", rettype = \"int32x4_t\", argtypes = \"[int32x4_t,int32x4_t]\", vals = [VectorVal [IntegerVal 65535,IntegerVal (-32768),IntegerVal (-32769),IntegerVal (-32769)],VectorVal [IntegerVal (-35686),IntegerVal 2147450879,IntegerVal 1413873664,IntegerVal (-1)]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s32(vcreate_s32(UINT64_C(0xffff80000000ffff)),
                          vcreate_s32(UINT64_C(0xffff7fffffff7fff)));
      arg2 = vcombine_s32(vcreate_s32(UINT64_C(0x7fff7fffffff749a)),
                          vcreate_s32(UINT64_C(0xffffffff54460000)));
      clear_neon_saturated();
      //  Expect: "result" = 00000000ffffabb9ffff8001ffffffff
      result = vqrdmulhq_s32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 0);
         exp = UINT64_C(0xffff8001ffffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 1);
         exp = UINT64_C(0x00000000ffffabb9);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_241() {

{
   {
      int16_t arg1;
      int16_t arg2;
      int16_t result;
      char* str1 = "ReproInfo2 {semantics = \"qrdmlh\", fnname = \"vqrdmulhh_s16\", rettype = \"int16_t\", argtypes = \"[int16_t,int16_t]\", vals = [IntegerVal 2310,IntegerVal 32767], start_saturated = False}";
      int reported = 0;
      int16_t got;
      int16_t exp;
      arg1 = 2310;
      arg2 = 32767;
      clear_neon_saturated();
      //  Expect: "result" = 0906
      result = vqrdmulhh_s16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = 2310;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIi16 " Got: %" PRIi16 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_242() {

{
   {
      int32_t arg1;
      int32_t arg2;
      int32_t result;
      char* str1 = "ReproInfo2 {semantics = \"qrdmlh\", fnname = \"vqrdmulhs_s32\", rettype = \"int32_t\", argtypes = \"[int32_t,int32_t]\", vals = [IntegerVal (-32769),IntegerVal 2147418112], start_saturated = False}";
      int reported = 0;
      int32_t got;
      int32_t exp;
      arg1 = -32769;
      arg2 = 2147418112;
      clear_neon_saturated();
      //  Expect: "result" = ffff8000
      result = vqrdmulhs_s32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = -32768;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIi32 " Got: %" PRIi32 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_243() {

{
   {
      int32x4_t arg1;
      int16x4_t arg2;
      int16x4_t arg3;
      int32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"qdmla\", fnname = \"vqdmlal_s16\", rettype = \"int32x4_t\", argtypes = \"[int32x4_t,int16x4_t,int16x4_t]\", vals = [VectorVal [IntegerVal (-32769),IntegerVal (-32769),IntegerVal (-2147418113),IntegerVal 1664734237],VectorVal [IntegerVal (-25948),IntegerVal (-32768),IntegerVal (-32768),IntegerVal (-32768)],VectorVal [IntegerVal 0,IntegerVal (-32768),IntegerVal (-32768),IntegerVal 32767]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s32(vcreate_s32(UINT64_C(0xffff7fffffff7fff)),
                          vcreate_s32(UINT64_C(0x6339d41d8000ffff)));
      arg2 = vcreate_s16(UINT64_C(0x8000800080009aa4));
      arg3 = vcreate_s16(UINT64_C(0x7fff800080000000));
      clear_neon_saturated();
      //  Expect: "result" = e33ad41d0000fffe7fff7ffeffff7fff
      result = vqdmlal_s16(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 0);
         exp = UINT64_C(0x7fff7ffeffff7fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 1);
         exp = UINT64_C(0xe33ad41d0000fffe);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_244() {

{
   {
      int64x2_t arg1;
      int32x2_t arg2;
      int32x2_t arg3;
      int64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"qdmla\", fnname = \"vqdmlal_s32\", rettype = \"int64x2_t\", argtypes = \"[int64x2_t,int32x2_t,int32x2_t]\", vals = [VectorVal [IntegerVal 8150811635951337471,IntegerVal 140735340904447],VectorVal [IntegerVal (-1),IntegerVal 2147418112],VectorVal [IntegerVal (-2147450880),IntegerVal (-1)]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s64(vcreate_s64(UINT64_C(0x711d7fff7fffffff)),
                          vcreate_s64(UINT64_C(0x00007fff80007fff)));
      arg2 = vcreate_s32(UINT64_C(0x7fff0000ffffffff));
      arg3 = vcreate_s32(UINT64_C(0xffffffff80008000));
      clear_neon_saturated();
      //  Expect: "result" = 00007ffe80027fff711d80007ffeffff
      result = vqdmlal_s32(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 0);
         exp = UINT64_C(0x711d80007ffeffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 1);
         exp = UINT64_C(0x00007ffe80027fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_245() {

{
   {
      int32_t arg1;
      int16_t arg2;
      int16_t arg3;
      int32_t result;
      char* str1 = "ReproInfo2 {semantics = \"qdmla\", fnname = \"vqdmlalh_s16\", rettype = \"int32_t\", argtypes = \"[int32_t,int16_t,int16_t]\", vals = [IntegerVal (-2147418113),IntegerVal (-32768),IntegerVal (-1)], start_saturated = False}";
      int reported = 0;
      int32_t got;
      int32_t exp;
      arg1 = -2147418113;
      arg2 = -32768;
      arg3 = -1;
      clear_neon_saturated();
      //  Expect: "result" = 8001ffff
      result = vqdmlalh_s16(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = -2147352577;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIi32 " Got: %" PRIi32 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_246() {

{
   {
      int64_t arg1;
      int32_t arg2;
      int32_t arg3;
      int64_t result;
      char* str1 = "ReproInfo2 {semantics = \"qdmla\", fnname = \"vqdmlals_s32\", rettype = \"int64_t\", argtypes = \"[int64_t,int32_t,int32_t]\", vals = [IntegerVal (-140737918042113),IntegerVal (-2147450880),IntegerVal (-2147443200)], start_saturated = False}";
      int reported = 0;
      int64_t got;
      int64_t exp;
      arg1 = INT64_C(-140737918042113);
      arg2 = -2147450880;
      arg3 = -2147443200;
      clear_neon_saturated();
      //  Expect: "result" = 7ffe620084637fff
      result = vqdmlals_s32(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = INT64_C(9222916841261989887);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIi64 " Got: %" PRIi64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_247() {

{
   {
      int32x4_t arg1;
      int16x8_t arg2;
      int16x8_t arg3;
      int32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"qdmla\", fnname = \"vqdmlal_high_s16\", rettype = \"int32x4_t\", argtypes = \"[int32x4_t,int16x8_t,int16x8_t]\", vals = [VectorVal [IntegerVal (-2147450881),IntegerVal 32768,IntegerVal (-2147450881),IntegerVal 32767],VectorVal [IntegerVal (-1),IntegerVal (-32768),IntegerVal (-32768),IntegerVal 0,IntegerVal 32767,IntegerVal 0,IntegerVal (-32768),IntegerVal (-32768)],VectorVal [IntegerVal 0,IntegerVal (-32768),IntegerVal 32767,IntegerVal 0,IntegerVal 32767,IntegerVal 3846,IntegerVal 32767,IntegerVal 0]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s32(vcreate_s32(UINT64_C(0x0000800080007fff)),
                          vcreate_s32(UINT64_C(0x00007fff80007fff)));
      arg2 = vcombine_s16(vcreate_s16(UINT64_C(0x000080008000ffff)),
                          vcreate_s16(UINT64_C(0x8000800000007fff)));
      arg3 = vcombine_s16(vcreate_s16(UINT64_C(0x00007fff80000000)),
                          vcreate_s16(UINT64_C(0x00007fff0f067fff)));
      clear_neon_saturated();
      //  Expect: "result" = 00007fff8000000000008000fffe8001
      result = vqdmlal_high_s16(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 0);
         exp = UINT64_C(0x00008000fffe8001);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 1);
         exp = UINT64_C(0x00007fff80000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_248() {

{
   {
      int64x2_t arg1;
      int32x4_t arg2;
      int32x4_t arg3;
      int64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"qdmla\", fnname = \"vqdmlal_high_s32\", rettype = \"int64x2_t\", argtypes = \"[int64x2_t,int32x4_t,int32x4_t]\", vals = [VectorVal [IntegerVal 279787054563328,IntegerVal 281470681803008],VectorVal [IntegerVal (-32122),IntegerVal (-1),IntegerVal (-1),IntegerVal (-680525824)],VectorVal [IntegerVal 2147450879,IntegerVal 0,IntegerVal 739335104,IntegerVal 41264]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s64(vcreate_s64(UINT64_C(0x0000fe7700000000)),
                          vcreate_s64(UINT64_C(0x0000ffff0000e900)));
      arg2 = vcombine_s32(vcreate_s32(UINT64_C(0xffffffffffff8286)),
                          vcreate_s32(UINT64_C(0xd7700000ffffffff)));
      arg3 = vcombine_s32(vcreate_s32(UINT64_C(0x000000007fff7fff)),
                          vcreate_s32(UINT64_C(0x0000a1302c115bc0)));
      clear_neon_saturated();
      //  Expect: "result" = 0000cceaaa00e9000000fe76a7dd4880
      result = vqdmlal_high_s32(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 0);
         exp = UINT64_C(0x0000fe76a7dd4880);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 1);
         exp = UINT64_C(0x0000cceaaa00e900);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_249() {

{
   {
      int32x4_t arg1;
      int16x4_t arg2;
      int16x4_t arg3;
      int32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"qdmls\", fnname = \"vqdmlsl_s16\", rettype = \"int32x4_t\", argtypes = \"[int32x4_t,int16x4_t,int16x4_t]\", vals = [VectorVal [IntegerVal (-2147464260),IntegerVal 0,IntegerVal 32768,IntegerVal (-32768)],VectorVal [IntegerVal 28128,IntegerVal (-1),IntegerVal 32767,IntegerVal (-32768)],VectorVal [IntegerVal 0,IntegerVal (-1),IntegerVal 32767,IntegerVal (-32768)]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s32(vcreate_s32(UINT64_C(0x0000000080004bbc)),
                          vcreate_s32(UINT64_C(0xffff800000008000)));
      arg2 = vcreate_s16(UINT64_C(0x80007fffffff6de0));
      arg3 = vcreate_s16(UINT64_C(0x80007fffffff0000));
      clear_neon_saturated();
      //  Expect: "result" = 8000000080027ffefffffffe80004bbc
      result = vqdmlsl_s16(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 0);
         exp = UINT64_C(0xfffffffe80004bbc);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 1);
         exp = UINT64_C(0x8000000080027ffe);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_250() {

{
   {
      int64x2_t arg1;
      int32x2_t arg2;
      int32x2_t arg3;
      int64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"qdmls\", fnname = \"vqdmlsl_s32\", rettype = \"int64x2_t\", argtypes = \"[int64x2_t,int32x2_t,int32x2_t]\", vals = [VectorVal [IntegerVal 9223349402377093120,IntegerVal 281472829227008],VectorVal [IntegerVal 476250111,IntegerVal 2147450880],VectorVal [IntegerVal 1839333376,IntegerVal (-64365)]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s64(vcreate_s64(UINT64_C(0x7fffeb69ffff8000)),
                          vcreate_s64(UINT64_C(0x0000ffff80000000)));
      arg2 = vcreate_s32(UINT64_C(0x7fff80001c62ffff));
      arg3 = vcreate_s32(UINT64_C(0xffff04936da20000));
      clear_neon_saturated();
      //  Expect: "result" = 0001fb6b8493000067afb01edb438000
      result = vqdmlsl_s32(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 0);
         exp = UINT64_C(0x67afb01edb438000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 1);
         exp = UINT64_C(0x0001fb6b84930000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_251() {

{
   {
      int32_t arg1;
      int16_t arg2;
      int16_t arg3;
      int32_t result;
      char* str1 = "ReproInfo2 {semantics = \"qdmls\", fnname = \"vqdmlslh_s16\", rettype = \"int32_t\", argtypes = \"[int32_t,int16_t,int16_t]\", vals = [IntegerVal 2147483647,IntegerVal 32767,IntegerVal 0], start_saturated = False}";
      int reported = 0;
      int32_t got;
      int32_t exp;
      arg1 = 2147483647;
      arg2 = 32767;
      arg3 = 0;
      clear_neon_saturated();
      //  Expect: "result" = 7fffffff
      result = vqdmlslh_s16(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = 2147483647;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIi32 " Got: %" PRIi32 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_252() {

{
   {
      int64_t arg1;
      int32_t arg2;
      int32_t arg3;
      int64_t result;
      char* str1 = "ReproInfo2 {semantics = \"qdmls\", fnname = \"vqdmlsls_s32\", rettype = \"int64_t\", argtypes = \"[int64_t,int32_t,int32_t]\", vals = [IntegerVal (-9197335599361589249),IntegerVal (-331415552),IntegerVal (-456622081)], start_saturated = False}";
      int reported = 0;
      int64_t got;
      int64_t exp;
      arg1 = INT64_C(-9197335599361589249);
      arg2 = -331415552;
      arg3 = -456622081;
      clear_neon_saturated();
      //  Expect: "result" = 8000000000000000
      result = vqdmlsls_s32(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      got = result;
      exp = INT64_MIN;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIi64 " Got: %" PRIi64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_253() {

{
   {
      int32x4_t arg1;
      int16x8_t arg2;
      int16x8_t arg3;
      int32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"qdmls\", fnname = \"vqdmlsl_high_s16\", rettype = \"int32x4_t\", argtypes = \"[int32x4_t,int16x8_t,int16x8_t]\", vals = [VectorVal [IntegerVal (-32769),IntegerVal 32767,IntegerVal (-24460),IntegerVal (-2147450880)],VectorVal [IntegerVal (-15303),IntegerVal (-32768),IntegerVal (-32768),IntegerVal (-9107),IntegerVal 14949,IntegerVal 29539,IntegerVal 0,IntegerVal (-1)],VectorVal [IntegerVal 32767,IntegerVal (-32768),IntegerVal 0,IntegerVal 22666,IntegerVal (-32768),IntegerVal (-32768),IntegerVal 2177,IntegerVal 0]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s32(vcreate_s32(UINT64_C(0x00007fffffff7fff)),
                          vcreate_s32(UINT64_C(0x80008000ffffa074)));
      arg2 = vcombine_s16(vcreate_s16(UINT64_C(0xdc6d80008000c439)),
                          vcreate_s16(UINT64_C(0xffff000073633a65)));
      arg3 = vcombine_s16(vcreate_s16(UINT64_C(0x588a000080007fff)),
                          vcreate_s16(UINT64_C(0x0000088180008000)));
      clear_neon_saturated();
      //  Expect: "result" = 80008000ffffa07473637fff3a647fff
      result = vqdmlsl_high_s16(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 0);
         exp = UINT64_C(0x73637fff3a647fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 1);
         exp = UINT64_C(0x80008000ffffa074);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_254() {

{
   {
      int64x2_t arg1;
      int32x4_t arg2;
      int32x4_t arg3;
      int64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"qdmls\", fnname = \"vqdmlsl_high_s32\", rettype = \"int64x2_t\", argtypes = \"[int64x2_t,int32x4_t,int32x4_t]\", vals = [VectorVal [IntegerVal 2048152665132630016,IntegerVal (-164254581786222)],VectorVal [IntegerVal (-32769),IntegerVal (-2147450881),IntegerVal (-2147483648),IntegerVal 37414],VectorVal [IntegerVal 2147458893,IntegerVal 0,IntegerVal (-32768),IntegerVal (-2147450881)]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s64(vcreate_s64(UINT64_C(0x1c6c7fff53000000)),
                          vcreate_s64(UINT64_C(0xffff6a9c7ffff992)));
      arg2 = vcombine_s32(vcreate_s32(UINT64_C(0x80007fffffff7fff)),
                          vcreate_s32(UINT64_C(0x0000922680000000)));
      arg3 = vcombine_s32(vcreate_s32(UINT64_C(0x000000007fff9f4d)),
                          vcreate_s32(UINT64_C(0x80007fffffff8000)));
      clear_neon_saturated();
      //  Expect: "result" = fffffcc1eddb1dde1c6bffff53000000
      result = vqdmlsl_high_s32(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 0);
         exp = UINT64_C(0x1c6bffff53000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 1);
         exp = UINT64_C(0xfffffcc1eddb1dde);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_255() {

{
   {
      int8x8_t arg1;
      int8x8_t arg2;
      int16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"mul\", fnname = \"vmull_s8\", rettype = \"int16x8_t\", argtypes = \"[int8x8_t,int8x8_t]\", vals = [VectorVal [IntegerVal 0,IntegerVal 0,IntegerVal (-1),IntegerVal (-1),IntegerVal 99,IntegerVal 0,IntegerVal 124,IntegerVal (-1)],VectorVal [IntegerVal 127,IntegerVal (-128),IntegerVal (-128),IntegerVal (-1),IntegerVal 0,IntegerVal 0,IntegerVal 0,IntegerVal (-128)]], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_s8(UINT64_C(0xff7c0063ffff0000));
      arg2 = vcreate_s8(UINT64_C(0x80000000ff80807f));
      clear_neon_saturated();
      //  Expect: "result" = 00800000000000000001008000000000
      result = vmull_s8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 0);
         exp = UINT64_C(0x0001008000000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 1);
         exp = UINT64_C(0x0080000000000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_256() {

{
   {
      int16x4_t arg1;
      int16x4_t arg2;
      int32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"mul\", fnname = \"vmull_s16\", rettype = \"int32x4_t\", argtypes = \"[int16x4_t,int16x4_t]\", vals = [VectorVal [IntegerVal (-1),IntegerVal 0,IntegerVal 32767,IntegerVal 0],VectorVal [IntegerVal 0,IntegerVal 0,IntegerVal 0,IntegerVal 32767]], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_s16(UINT64_C(0x00007fff0000ffff));
      arg2 = vcreate_s16(UINT64_C(0x7fff000000000000));
      clear_neon_saturated();
      //  Expect: "result" = 00000000000000000000000000000000
      result = vmull_s16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 0);
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 1);
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_257() {

{
   {
      int32x2_t arg1;
      int32x2_t arg2;
      int64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"mul\", fnname = \"vmull_s32\", rettype = \"int64x2_t\", argtypes = \"[int32x2_t,int32x2_t]\", vals = [VectorVal [IntegerVal (-1746501633),IntegerVal (-2147450881)],VectorVal [IntegerVal 2147450879,IntegerVal 32767]], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_s32(UINT64_C(0x80007fff97e67fff));
      arg2 = vcreate_s32(UINT64_C(0x00007fff7fff7fff));
      clear_neon_saturated();
      //  Expect: "result" = ffffc000bfff0001cbf3740ca81a0001
      result = vmull_s32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 0);
         exp = UINT64_C(0xcbf3740ca81a0001);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 1);
         exp = UINT64_C(0xffffc000bfff0001);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_258() {

{
   {
      uint8x8_t arg1;
      uint8x8_t arg2;
      uint16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"mul\", fnname = \"vmull_u8\", rettype = \"uint16x8_t\", argtypes = \"[uint8x8_t,uint8x8_t]\", vals = [VectorVal [IntegerVal 0,IntegerVal 255,IntegerVal 0,IntegerVal 127,IntegerVal 255,IntegerVal 255,IntegerVal 128,IntegerVal 127],VectorVal [IntegerVal 127,IntegerVal 0,IntegerVal 127,IntegerVal 127,IntegerVal 255,IntegerVal 255,IntegerVal 127,IntegerVal 200]], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_u8(UINT64_C(0x7f80ffff7f00ff00));
      arg2 = vcreate_u8(UINT64_C(0xc87fffff7f7f007f));
      clear_neon_saturated();
      //  Expect: "result" = 63383f80fe01fe013f01000000000000
      result = vmull_u8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 0);
         exp = UINT64_C(0x3f01000000000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 1);
         exp = UINT64_C(0x63383f80fe01fe01);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_259() {

{
   {
      uint16x4_t arg1;
      uint16x4_t arg2;
      uint32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"mul\", fnname = \"vmull_u16\", rettype = \"uint32x4_t\", argtypes = \"[uint16x4_t,uint16x4_t]\", vals = [VectorVal [IntegerVal 32767,IntegerVal 32768,IntegerVal 65535,IntegerVal 0],VectorVal [IntegerVal 65535,IntegerVal 65535,IntegerVal 65535,IntegerVal 45855]], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_u16(UINT64_C(0x0000ffff80007fff));
      arg2 = vcreate_u16(UINT64_C(0xb31fffffffffffff));
      clear_neon_saturated();
      //  Expect: "result" = 00000000fffe00017fff80007ffe8001
      result = vmull_u16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 0);
         exp = UINT64_C(0x7fff80007ffe8001);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 1);
         exp = UINT64_C(0x00000000fffe0001);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_260() {

{
   {
      uint32x2_t arg1;
      uint32x2_t arg2;
      uint64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"mul\", fnname = \"vmull_u32\", rettype = \"uint64x2_t\", argtypes = \"[uint32x2_t,uint32x2_t]\", vals = [VectorVal [IntegerVal 4294967295,IntegerVal 2147418112],VectorVal [IntegerVal 2147483647,IntegerVal 2070249472]], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_u32(UINT64_C(0x7fff0000ffffffff));
      arg2 = vcreate_u32(UINT64_C(0x7b6580007fffffff));
      clear_neon_saturated();
      //  Expect: "result" = 3db2449a800000007ffffffe80000001
      result = vmull_u32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 0);
         exp = UINT64_C(0x7ffffffe80000001);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 1);
         exp = UINT64_C(0x3db2449a80000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_261() {

{
   {
      poly8x8_t arg1;
      poly8x8_t arg2;
      poly16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"mul\", fnname = \"vmull_p8\", rettype = \"poly16x8_t\", argtypes = \"[poly8x8_t,poly8x8_t]\", vals = [VectorVal [PolyVal [1,0,0,1,1,1,0,0],PolyVal [1,0,0,0,0,0,1,1],PolyVal [0,0,1,1,1,0,0,1],PolyVal [0,0,0,1,0,1,1,1],PolyVal [0,1,1,1,1,1,0,1],PolyVal [1,1,1,0,1,1,1,1],PolyVal [1,1,0,1,0,0,0,1],PolyVal [0,0,0,1,0,1,0,1]],VectorVal [PolyVal [0,0,1,0,0,1,0,1],PolyVal [1,0,1,0,0,0,1,0],PolyVal [0,0,1,0,0,1,0,1],PolyVal [0,0,1,0,0,1,1,0],PolyVal [0,0,1,0,0,0,0,1],PolyVal [1,1,1,1,0,1,0,1],PolyVal [0,0,1,0,0,0,1,1],PolyVal [1,0,0,0,0,1,0,0]]], start_saturated = True}";
      int reported = 0;
      arg1 = vcreate_p8(UINT64_C(0xa88bf7bee89cc139));
      arg2 = vcreate_p8(UINT64_C(0x21c4af8464a445a4));
      set_neon_saturated();
      //  Expect: "result" = 15a8656c601d5df824a05ff033851b44
      result = vmull_p8(arg1, arg2);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p16(result), 0);
         exp = UINT64_C(0x24a05ff033851b44);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p16(result), 1);
         exp = UINT64_C(0x15a8656c601d5df8);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_262() {

{
   {
      int8x16_t arg1;
      int8x16_t arg2;
      int16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"mul\", fnname = \"vmull_high_s8\", rettype = \"int16x8_t\", argtypes = \"[int8x16_t,int8x16_t]\", vals = [VectorVal [IntegerVal (-128),IntegerVal (-1),IntegerVal 127,IntegerVal 0,IntegerVal 127,IntegerVal 0,IntegerVal 127,IntegerVal (-128),IntegerVal 0,IntegerVal (-128),IntegerVal 0,IntegerVal (-1),IntegerVal 58,IntegerVal (-1),IntegerVal (-1),IntegerVal (-128)],VectorVal [IntegerVal (-1),IntegerVal (-128),IntegerVal (-1),IntegerVal (-128),IntegerVal (-128),IntegerVal (-1),IntegerVal (-1),IntegerVal 127,IntegerVal (-128),IntegerVal 43,IntegerVal 0,IntegerVal (-128),IntegerVal (-1),IntegerVal (-1),IntegerVal 0,IntegerVal (-128)]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s8(vcreate_s8(UINT64_C(0x807f007f007fff80)),
                         vcreate_s8(UINT64_C(0x80ffff3aff008000)));
      arg2 = vcombine_s8(vcreate_s8(UINT64_C(0x7fffff8080ff80ff)),
                         vcreate_s8(UINT64_C(0x8000ffff80002b80)));
      clear_neon_saturated();
      //  Expect: "result" = 400000000001ffc600800000ea800000
      result = vmull_high_s8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 0);
         exp = UINT64_C(0x00800000ea800000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 1);
         exp = UINT64_C(0x400000000001ffc6);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_263() {

{
   {
      int16x8_t arg1;
      int16x8_t arg2;
      int32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"mul\", fnname = \"vmull_high_s16\", rettype = \"int32x4_t\", argtypes = \"[int16x8_t,int16x8_t]\", vals = [VectorVal [IntegerVal 0,IntegerVal 32767,IntegerVal 32767,IntegerVal (-1),IntegerVal 0,IntegerVal 0,IntegerVal (-32768),IntegerVal 0],VectorVal [IntegerVal (-32768),IntegerVal 29647,IntegerVal 30390,IntegerVal 0,IntegerVal (-32768),IntegerVal (-31438),IntegerVal (-32768),IntegerVal 0]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s16(vcreate_s16(UINT64_C(0xffff7fff7fff0000)),
                          vcreate_s16(UINT64_C(0x0000800000000000)));
      arg2 = vcombine_s16(vcreate_s16(UINT64_C(0x000076b673cf8000)),
                          vcreate_s16(UINT64_C(0x0000800085328000)));
      clear_neon_saturated();
      //  Expect: "result" = 00000000400000000000000000000000
      result = vmull_high_s16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 0);
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 1);
         exp = UINT64_C(0x0000000040000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_264() {

{
   {
      int32x4_t arg1;
      int32x4_t arg2;
      int64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"mul\", fnname = \"vmull_high_s32\", rettype = \"int64x2_t\", argtypes = \"[int32x4_t,int32x4_t]\", vals = [VectorVal [IntegerVal (-2147424463),IntegerVal 2147483647,IntegerVal (-65536),IntegerVal 65535],VectorVal [IntegerVal 32768,IntegerVal (-2147483648),IntegerVal (-1),IntegerVal 2147483647]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s32(vcreate_s32(UINT64_C(0x7fffffff8000e731)),
                          vcreate_s32(UINT64_C(0x0000ffffffff0000)));
      arg2 = vcombine_s32(vcreate_s32(UINT64_C(0x8000000000008000)),
                          vcreate_s32(UINT64_C(0x7fffffffffffffff)));
      clear_neon_saturated();
      //  Expect: "result" = 00007fff7fff00010000000000010000
      result = vmull_high_s32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 0);
         exp = UINT64_C(0x0000000000010000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 1);
         exp = UINT64_C(0x00007fff7fff0001);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_265() {

{
   {
      uint8x16_t arg1;
      uint8x16_t arg2;
      uint16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"mul\", fnname = \"vmull_high_u8\", rettype = \"uint16x8_t\", argtypes = \"[uint8x16_t,uint8x16_t]\", vals = [VectorVal [IntegerVal 0,IntegerVal 0,IntegerVal 127,IntegerVal 0,IntegerVal 127,IntegerVal 39,IntegerVal 128,IntegerVal 128,IntegerVal 255,IntegerVal 127,IntegerVal 255,IntegerVal 255,IntegerVal 255,IntegerVal 127,IntegerVal 255,IntegerVal 128],VectorVal [IntegerVal 255,IntegerVal 127,IntegerVal 128,IntegerVal 127,IntegerVal 255,IntegerVal 127,IntegerVal 127,IntegerVal 218,IntegerVal 255,IntegerVal 255,IntegerVal 128,IntegerVal 128,IntegerVal 186,IntegerVal 0,IntegerVal 115,IntegerVal 255]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u8(vcreate_u8(UINT64_C(0x8080277f007f0000)),
                         vcreate_u8(UINT64_C(0x80ff7fffffff7fff)));
      arg2 = vcombine_u8(vcreate_u8(UINT64_C(0xda7f7fff7f807fff)),
                         vcreate_u8(UINT64_C(0xff7300ba8080ffff)));
      clear_neon_saturated();
      //  Expect: "result" = 7f80728d0000b9467f807f807e81fe01
      result = vmull_high_u8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 0);
         exp = UINT64_C(0x7f807f807e81fe01);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 1);
         exp = UINT64_C(0x7f80728d0000b946);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_266() {

{
   {
      uint16x8_t arg1;
      uint16x8_t arg2;
      uint32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"mul\", fnname = \"vmull_high_u16\", rettype = \"uint32x4_t\", argtypes = \"[uint16x8_t,uint16x8_t]\", vals = [VectorVal [IntegerVal 55242,IntegerVal 32768,IntegerVal 0,IntegerVal 0,IntegerVal 17296,IntegerVal 0,IntegerVal 0,IntegerVal 65535],VectorVal [IntegerVal 48135,IntegerVal 32767,IntegerVal 0,IntegerVal 32768,IntegerVal 65535,IntegerVal 0,IntegerVal 0,IntegerVal 43376]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u16(vcreate_u16(UINT64_C(0x000000008000d7ca)),
                          vcreate_u16(UINT64_C(0xffff000000004390)));
      arg2 = vcombine_u16(vcreate_u16(UINT64_C(0x800000007fffbc07)),
                          vcreate_u16(UINT64_C(0xa97000000000ffff)));
      clear_neon_saturated();
      //  Expect: "result" = a96f56900000000000000000438fbc70
      result = vmull_high_u16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 0);
         exp = UINT64_C(0x00000000438fbc70);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 1);
         exp = UINT64_C(0xa96f569000000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_267() {

{
   {
      uint32x4_t arg1;
      uint32x4_t arg2;
      uint64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"mul\", fnname = \"vmull_high_u32\", rettype = \"uint64x2_t\", argtypes = \"[uint32x4_t,uint32x4_t]\", vals = [VectorVal [IntegerVal 4294967295,IntegerVal 32768,IntegerVal 2147549183,IntegerVal 997883903],VectorVal [IntegerVal 4294934528,IntegerVal 65535,IntegerVal 2130974505,IntegerVal 2147516415]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u32(vcreate_u32(UINT64_C(0x00008000ffffffff)),
                          vcreate_u32(UINT64_C(0x3b7a7fff8000ffff)));
      arg2 = vcombine_u32(vcreate_u32(UINT64_C(0x0000ffffffff8000)),
                          vcreate_u32(UINT64_C(0x80007fff7f041729)));
      clear_neon_saturated();
      //  Expect: "result" = 1dbd5dbc848500013f828a981824e8d7
      result = vmull_high_u32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 0);
         exp = UINT64_C(0x3f828a981824e8d7);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 1);
         exp = UINT64_C(0x1dbd5dbc84850001);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_268() {

{
   {
      poly8x16_t arg1;
      poly8x16_t arg2;
      poly16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"mul\", fnname = \"vmull_high_p8\", rettype = \"poly16x8_t\", argtypes = \"[poly8x16_t,poly8x16_t]\", vals = [VectorVal [PolyVal [1,0,1,0,0,1,0,1],PolyVal [1,0,1,0,1,1,0,1],PolyVal [1,1,1,0,1,0,0,1],PolyVal [1,1,1,0,1,1,0,0],PolyVal [0,0,0,1,1,0,1,0],PolyVal [1,0,0,0,0,1,1,1],PolyVal [0,1,0,0,0,0,1,0],PolyVal [1,1,0,1,1,1,1,0],PolyVal [0,0,1,0,0,1,1,1],PolyVal [0,0,1,0,1,1,0,0],PolyVal [1,1,1,1,0,1,0,0],PolyVal [0,0,0,1,1,1,0,1],PolyVal [1,1,1,1,1,1,0,0],PolyVal [0,0,1,0,0,0,0,1],PolyVal [1,1,1,1,0,0,0,0],PolyVal [0,1,1,1,1,0,0,0]],VectorVal [PolyVal [1,0,1,1,1,1,1,0],PolyVal [0,0,1,1,0,0,1,1],PolyVal [1,0,1,1,0,0,0,1],PolyVal [0,1,0,1,0,0,0,0],PolyVal [1,0,0,0,1,0,1,0],PolyVal [1,1,1,1,0,1,0,1],PolyVal [0,1,1,0,1,1,1,0],PolyVal [1,0,1,0,0,0,0,1],PolyVal [1,1,0,1,1,1,1,0],PolyVal [1,0,0,1,0,1,1,1],PolyVal [1,0,0,0,0,1,0,1],PolyVal [1,0,1,0,1,1,1,0],PolyVal [0,1,1,0,0,0,1,0],PolyVal [1,1,0,0,1,0,0,1],PolyVal [1,0,0,1,0,0,1,1],PolyVal [0,1,1,1,1,1,1,0]]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_p8(vcreate_p8(UINT64_C(0x7b42e1583797b5a5)),
                         vcreate_p8(UINT64_C(0x1e0f843fb82f34e4)));
      arg2 = vcombine_p8(vcreate_p8(UINT64_C(0x8576af510a8dcc7d)),
                         vcreate_p8(UINT64_C(0x7ec9934675a1e97b)));
      clear_neon_saturated();
      //  Expect: "result" = 051404374bcc0f4230d8124f10142dcc
      result = vmull_high_p8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p16(result), 0);
         exp = UINT64_C(0x30d8124f10142dcc);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p16(result), 1);
         exp = UINT64_C(0x051404374bcc0f42);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_269() {

{
   {
      int16x4_t arg1;
      int16x4_t arg2;
      int32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"qdmul\", fnname = \"vqdmull_s16\", rettype = \"int32x4_t\", argtypes = \"[int16x4_t,int16x4_t]\", vals = [VectorVal [IntegerVal 0,IntegerVal (-32768),IntegerVal (-13834),IntegerVal 29258],VectorVal [IntegerVal (-1),IntegerVal 31869,IntegerVal (-1),IntegerVal (-1)]], start_saturated = True}";
      int reported = 0;
      arg1 = vcreate_s16(UINT64_C(0x724ac9f680000000));
      arg2 = vcreate_s16(UINT64_C(0xffffffff7c7dffff));
      set_neon_saturated();
      //  Expect: "result" = ffff1b6c00006c148383000000000000
      result = vqdmull_s16(arg1, arg2);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 0);
         exp = UINT64_C(0x8383000000000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 1);
         exp = UINT64_C(0xffff1b6c00006c14);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_270() {

{
   {
      int32x2_t arg1;
      int32x2_t arg2;
      int64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"qdmul\", fnname = \"vqdmull_s32\", rettype = \"int64x2_t\", argtypes = \"[int32x2_t,int32x2_t]\", vals = [VectorVal [IntegerVal 32768,IntegerVal (-32768)],VectorVal [IntegerVal 2147457208,IntegerVal 0]], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_s32(UINT64_C(0xffff800000008000));
      arg2 = vcreate_s32(UINT64_C(0x000000007fff98b8));
      clear_neon_saturated();
      //  Expect: "result" = 000000000000000000007fff98b80000
      result = vqdmull_s32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 0);
         exp = UINT64_C(0x00007fff98b80000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 1);
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_271() {

{
   {
      int16_t arg1;
      int16_t arg2;
      int32_t result;
      char* str1 = "ReproInfo2 {semantics = \"qdmul\", fnname = \"vqdmullh_s16\", rettype = \"int32_t\", argtypes = \"[int16_t,int16_t]\", vals = [IntegerVal (-1),IntegerVal 0], start_saturated = False}";
      int reported = 0;
      int32_t got;
      int32_t exp;
      arg1 = -1;
      arg2 = 0;
      clear_neon_saturated();
      //  Expect: "result" = 00000000
      result = vqdmullh_s16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = 0;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIi32 " Got: %" PRIi32 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_272() {

{
   {
      int32_t arg1;
      int32_t arg2;
      int64_t result;
      char* str1 = "ReproInfo2 {semantics = \"qdmul\", fnname = \"vqdmulls_s32\", rettype = \"int64_t\", argtypes = \"[int32_t,int32_t]\", vals = [IntegerVal (-1664745473),IntegerVal (-2147483648)], start_saturated = False}";
      int reported = 0;
      int64_t got;
      int64_t exp;
      arg1 = -1664745473;
      arg2 = (int32_t) 0x80000000;
      clear_neon_saturated();
      //  Expect: "result" = 633a000100000000
      result = vqdmulls_s32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = INT64_C(7150027362699051008);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIi64 " Got: %" PRIi64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_273() {

{
   {
      int16x8_t arg1;
      int16x8_t arg2;
      int32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"qdmul\", fnname = \"vqdmull_high_s16\", rettype = \"int32x4_t\", argtypes = \"[int16x8_t,int16x8_t]\", vals = [VectorVal [IntegerVal (-9963),IntegerVal (-32768),IntegerVal 17025,IntegerVal (-32768),IntegerVal 4215,IntegerVal (-1),IntegerVal 29099,IntegerVal (-31618)],VectorVal [IntegerVal (-32768),IntegerVal (-32768),IntegerVal 32767,IntegerVal (-32768),IntegerVal 0,IntegerVal 0,IntegerVal (-1),IntegerVal (-32768)]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s16(vcreate_s16(UINT64_C(0x800042818000d915)),
                          vcreate_s16(UINT64_C(0x847e71abffff1077)));
      arg2 = vcombine_s16(vcreate_s16(UINT64_C(0x80007fff80008000)),
                          vcreate_s16(UINT64_C(0x8000ffff00000000)));
      clear_neon_saturated();
      //  Expect: "result" = 7b820000ffff1caa0000000000000000
      result = vqdmull_high_s16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 0);
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 1);
         exp = UINT64_C(0x7b820000ffff1caa);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_274() {

{
   {
      int32x4_t arg1;
      int32x4_t arg2;
      int64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"qdmul\", fnname = \"vqdmull_high_s32\", rettype = \"int64x2_t\", argtypes = \"[int32x4_t,int32x4_t]\", vals = [VectorVal [IntegerVal (-2147418113),IntegerVal (-791314433),IntegerVal 1878261759,IntegerVal 1425408000],VectorVal [IntegerVal (-32769),IntegerVal 2147450880,IntegerVal (-32768),IntegerVal (-867433466)]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s32(vcreate_s32(UINT64_C(0xd0d57fff8000ffff)),
                          vcreate_s32(UINT64_C(0x54f600006ff3ffff)));
      arg2 = vcombine_s32(vcreate_s32(UINT64_C(0x7fff8000ffff7fff)),
                          vcreate_s32(UINT64_C(0xcc4c0406ffff8000)));
      clear_neon_saturated();
      //  Expect: "result" = ddae84bbab880000ffff900c00010000
      result = vqdmull_high_s32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 0);
         exp = UINT64_C(0xffff900c00010000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 1);
         exp = UINT64_C(0xddae84bbab880000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_275() {

{
   {
      float32x2_t arg1;
      float32x2_t arg2;
      float32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"div\", fnname = \"vdiv_f32\", rettype = \"float32x2_t\", argtypes = \"[float32x2_t,float32x2_t]\", vals = [VectorVal [FloatVal 0.3943381905555725,FloatVal 0.10620331764221191],VectorVal [FloatVal 0.24389833211898804,FloatVal 0.793936014175415]], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_f32(UINT64_C(0x3dd981203ec9e6b2));
      arg2 = vcreate_f32(UINT64_C(0x3f4b3f643e79c07c));
      clear_neon_saturated();
      //  Expect: "result" = 3e08fa823fcef3c1
      result = vdiv_f32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result, 0);
         exp = ((float32_t) 1.6168137788772583);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result, 1);
         exp = ((float32_t) 0.13376811146736145);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
   }
}
}
void dotests_276() {

{
   {
      float64x1_t arg1;
      float64x1_t arg2;
      float64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"div\", fnname = \"vdiv_f64\", rettype = \"float64x1_t\", argtypes = \"[float64x1_t,float64x1_t]\", vals = [VectorVal [FloatVal 0.42691917315532213],VectorVal [FloatVal 5.333014278155601e-2]], start_saturated = False}";
      int reported = 0;
      float64_t got;
      float64_t exp;
      arg1 = vcreate_f64(UINT64_C(0x3fdb52a4cbaf32b4));
      arg2 = vcreate_f64(UINT64_C(0x3fab4e16a6468ce0));
      clear_neon_saturated();
      //  Expect: "result" = 402002ab54625854
      result = vdiv_f64(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_f64(result, 0);
      exp = 8.005213391308793;
      if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
         }
   }
}
}
void dotests_277() {

{
   {
      float32x4_t arg1;
      float32x4_t arg2;
      float32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"div\", fnname = \"vdivq_f32\", rettype = \"float32x4_t\", argtypes = \"[float32x4_t,float32x4_t]\", vals = [VectorVal [FloatVal 0.9860303997993469,FloatVal 2.8651535511016846e-2,FloatVal 0.32012295722961426,FloatVal 1.9760191440582275e-2],VectorVal [FloatVal 0.49116039276123047,FloatVal 8.336400985717773e-2,FloatVal 0.45163965225219727,FloatVal 0.8752203583717346]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_f32(vcreate_f32(UINT64_C(0x3ceab6a03f7c6c7d)),
                          vcreate_f32(UINT64_C(0x3ca1e0203ea3e728)));
      arg2 = vcombine_f32(vcreate_f32(UINT64_C(0x3daabac03efb7960)),
                          vcreate_f32(UINT64_C(0x3f600e713ee73d50)));
      clear_neon_saturated();
      //  Expect: "result" = 3cb8f4383f3574073eaff86340007bbf
      result = vdivq_f32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 0);
         exp = ((float32_t) 2.0075528621673584);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 1);
         exp = ((float32_t) 0.3436919152736664);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 2);
         exp = ((float32_t) 0.7088016867637634);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 2 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 3);
         exp = ((float32_t) 2.257739007472992e-2);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 3 ", exp, got);
            }
      }
   }
}
}
void dotests_278() {

{
   {
      float64x2_t arg1;
      float64x2_t arg2;
      float64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"div\", fnname = \"vdivq_f64\", rettype = \"float64x2_t\", argtypes = \"[float64x2_t,float64x2_t]\", vals = [VectorVal [FloatVal 0.49584213293553303,FloatVal 0.5483966758710147],VectorVal [FloatVal 0.10229001214715716,FloatVal 0.5381493677929209]], start_saturated = True}";
      int reported = 0;
      arg1 = vcombine_f64(vcreate_f64(UINT64_C(0x3fdfbbe0a43bf7ca)),
                          vcreate_f64(UINT64_C(0x3fe18c772f833c61)));
      arg2 = vcombine_f64(vcreate_f64(UINT64_C(0x3fba2fada0e125c8)),
                          vcreate_f64(UINT64_C(0x3fe1388505e113d5)));
      set_neon_saturated();
      //  Expect: "result" = 3ff04dfeba04b95d401363c0bddaffcf
      result = vdivq_f64(arg1, arg2);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      {
         float64_t got;
         float64_t exp;
         got = vgetq_lane_f64(result, 0);
         exp = 4.8474149384419;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float64_t got;
         float64_t exp;
         got = vgetq_lane_f64(result, 1);
         exp = 1.019041754374107;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
   }
}
}
void dotests_279() {

{
   {
      int8x8_t arg1;
      int8x8_t arg2;
      int8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"sub\", fnname = \"vsub_s8\", rettype = \"int8x8_t\", argtypes = \"[int8x8_t,int8x8_t]\", vals = [VectorVal [IntegerVal 0,IntegerVal 127,IntegerVal (-128),IntegerVal (-1),IntegerVal 0,IntegerVal 0,IntegerVal 0,IntegerVal 127],VectorVal [IntegerVal (-128),IntegerVal (-128),IntegerVal 0,IntegerVal 127,IntegerVal 45,IntegerVal 0,IntegerVal (-122),IntegerVal 127]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s8(UINT64_C(0x7f000000ff807f00));
      arg2 = vcreate_s8(UINT64_C(0x7f86002d7f008080));
      clear_neon_saturated();
      //  Expect: "result" = 007a00d38080ff80
      result = vsub_s8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s8(result), 0);
      exp = UINT64_C(0x007a00d38080ff80);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_280() {

{
   {
      int16x4_t arg1;
      int16x4_t arg2;
      int16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"sub\", fnname = \"vsub_s16\", rettype = \"int16x4_t\", argtypes = \"[int16x4_t,int16x4_t]\", vals = [VectorVal [IntegerVal 0,IntegerVal (-616),IntegerVal (-9023),IntegerVal (-1)],VectorVal [IntegerVal (-32768),IntegerVal (-32734),IntegerVal 0,IntegerVal (-1)]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s16(UINT64_C(0xffffdcc1fd980000));
      arg2 = vcreate_s16(UINT64_C(0xffff000080228000));
      clear_neon_saturated();
      //  Expect: "result" = 0000dcc17d768000
      result = vsub_s16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s16(result), 0);
      exp = UINT64_C(0x0000dcc17d768000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_281() {

{
   {
      int32x2_t arg1;
      int32x2_t arg2;
      int32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"sub\", fnname = \"vsub_s32\", rettype = \"int32x2_t\", argtypes = \"[int32x2_t,int32x2_t]\", vals = [VectorVal [IntegerVal 32767,IntegerVal 2147433289],VectorVal [IntegerVal (-2147418113),IntegerVal 22408]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s32(UINT64_C(0x7fff3b4900007fff));
      arg2 = vcreate_s32(UINT64_C(0x000057888000ffff));
      clear_neon_saturated();
      //  Expect: "result" = 7ffee3c17fff8000
      result = vsub_s32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s32(result), 0);
      exp = UINT64_C(0x7ffee3c17fff8000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_282() {

{
   {
      int64x1_t arg1;
      int64x1_t arg2;
      int64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"sub\", fnname = \"vsub_s64\", rettype = \"int64x1_t\", argtypes = \"[int64x1_t,int64x1_t]\", vals = [VectorVal [IntegerVal (-140741068390401)],VectorVal [IntegerVal (-136985834455041)]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s64(UINT64_C(0xffff7fff2a9cffff));
      arg2 = vcreate_s64(UINT64_C(0xffff83697fff7fff));
      clear_neon_saturated();
      //  Expect: "result" = fffffc95aa9d8000
      result = vsub_s64(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s64(result), 0);
      exp = UINT64_C(0xfffffc95aa9d8000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_283() {

{
   {
      float32x2_t arg1;
      float32x2_t arg2;
      float32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"sub\", fnname = \"vsub_f32\", rettype = \"float32x2_t\", argtypes = \"[float32x2_t,float32x2_t]\", vals = [VectorVal [FloatVal 4.768824577331543e-2,FloatVal 0.8095514178276062],VectorVal [FloatVal 0.6507919430732727,FloatVal 0.2855151891708374]], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_f32(UINT64_C(0x3f4f3ec33d4354c0));
      arg2 = vcreate_f32(UINT64_C(0x3e922f0c3f269a4d));
      clear_neon_saturated();
      //  Expect: "result" = 3f06273dbf1a6501
      result = vsub_f32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result, 0);
         exp = ((float32_t) -0.6031036972999573);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result, 1);
         exp = ((float32_t) 0.5240362286567688);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
   }
}
}
void dotests_284() {

{
   {
      uint8x8_t arg1;
      uint8x8_t arg2;
      uint8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"sub\", fnname = \"vsub_u8\", rettype = \"uint8x8_t\", argtypes = \"[uint8x8_t,uint8x8_t]\", vals = [VectorVal [IntegerVal 128,IntegerVal 128,IntegerVal 127,IntegerVal 255,IntegerVal 128,IntegerVal 80,IntegerVal 0,IntegerVal 127],VectorVal [IntegerVal 162,IntegerVal 54,IntegerVal 0,IntegerVal 255,IntegerVal 255,IntegerVal 82,IntegerVal 255,IntegerVal 255]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u8(UINT64_C(0x7f005080ff7f8080));
      arg2 = vcreate_u8(UINT64_C(0xffff52ffff0036a2));
      clear_neon_saturated();
      //  Expect: "result" = 8001fe81007f4ade
      result = vsub_u8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u8(result), 0);
      exp = UINT64_C(0x8001fe81007f4ade);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_285() {

{
   {
      uint16x4_t arg1;
      uint16x4_t arg2;
      uint16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"sub\", fnname = \"vsub_u16\", rettype = \"uint16x4_t\", argtypes = \"[uint16x4_t,uint16x4_t]\", vals = [VectorVal [IntegerVal 0,IntegerVal 32767,IntegerVal 32767,IntegerVal 65535],VectorVal [IntegerVal 65535,IntegerVal 32767,IntegerVal 65535,IntegerVal 32768]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u16(UINT64_C(0xffff7fff7fff0000));
      arg2 = vcreate_u16(UINT64_C(0x8000ffff7fffffff));
      clear_neon_saturated();
      //  Expect: "result" = 7fff800000000001
      result = vsub_u16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u16(result), 0);
      exp = UINT64_C(0x7fff800000000001);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_286() {

{
   {
      uint32x2_t arg1;
      uint32x2_t arg2;
      uint32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"sub\", fnname = \"vsub_u32\", rettype = \"uint32x2_t\", argtypes = \"[uint32x2_t,uint32x2_t]\", vals = [VectorVal [IntegerVal 4294950460,IntegerVal 65535],VectorVal [IntegerVal 2147418112,IntegerVal 4294967295]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u32(UINT64_C(0x0000ffffffffbe3c));
      arg2 = vcreate_u32(UINT64_C(0xffffffff7fff0000));
      clear_neon_saturated();
      //  Expect: "result" = 000100008000be3c
      result = vsub_u32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u32(result), 0);
      exp = UINT64_C(0x000100008000be3c);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_287() {

{
   {
      uint64x1_t arg1;
      uint64x1_t arg2;
      uint64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"sub\", fnname = \"vsub_u64\", rettype = \"uint64x1_t\", argtypes = \"[uint64x1_t,uint64x1_t]\", vals = [VectorVal [IntegerVal 65535],VectorVal [IntegerVal 9223512774343163067]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u64(UINT64_C(0x000000000000ffff));
      arg2 = vcreate_u64(UINT64_C(0x8000800000007cbb));
      clear_neon_saturated();
      //  Expect: "result" = 7fff800000008344
      result = vsub_u64(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(result, 0);
      exp = UINT64_C(0x7fff800000008344);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_288() {

{
   {
      int8x16_t arg1;
      int8x16_t arg2;
      int8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"sub\", fnname = \"vsubq_s8\", rettype = \"int8x16_t\", argtypes = \"[int8x16_t,int8x16_t]\", vals = [VectorVal [IntegerVal (-1),IntegerVal 57,IntegerVal (-48),IntegerVal (-60),IntegerVal (-128),IntegerVal 0,IntegerVal 127,IntegerVal 127,IntegerVal (-1),IntegerVal (-128),IntegerVal 0,IntegerVal 0,IntegerVal 127,IntegerVal 0,IntegerVal 127,IntegerVal 127],VectorVal [IntegerVal 0,IntegerVal (-1),IntegerVal (-1),IntegerVal (-1),IntegerVal 111,IntegerVal 127,IntegerVal 127,IntegerVal 0,IntegerVal 127,IntegerVal (-128),IntegerVal (-28),IntegerVal (-101),IntegerVal 70,IntegerVal 127,IntegerVal (-128),IntegerVal 127]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s8(vcreate_s8(UINT64_C(0x7f7f0080c4d039ff)),
                         vcreate_s8(UINT64_C(0x7f7f007f000080ff)));
      arg2 = vcombine_s8(vcreate_s8(UINT64_C(0x007f7f6fffffff00)),
                         vcreate_s8(UINT64_C(0x7f807f469be4807f)));
      clear_neon_saturated();
      //  Expect: "result" = 00ff8139651c00807f008111c5d13aff
      result = vsubq_s8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result), 0);
         exp = UINT64_C(0x7f008111c5d13aff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result), 1);
         exp = UINT64_C(0x00ff8139651c0080);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_289() {

{
   {
      int16x8_t arg1;
      int16x8_t arg2;
      int16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"sub\", fnname = \"vsubq_s16\", rettype = \"int16x8_t\", argtypes = \"[int16x8_t,int16x8_t]\", vals = [VectorVal [IntegerVal (-32768),IntegerVal (-32768),IntegerVal (-32768),IntegerVal (-1454),IntegerVal (-1),IntegerVal 32767,IntegerVal (-32768),IntegerVal 17881],VectorVal [IntegerVal 0,IntegerVal 0,IntegerVal 32767,IntegerVal (-18513),IntegerVal 32459,IntegerVal 27292,IntegerVal 32767,IntegerVal 0]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s16(vcreate_s16(UINT64_C(0xfa52800080008000)),
                          vcreate_s16(UINT64_C(0x45d980007fffffff)));
      arg2 = vcombine_s16(vcreate_s16(UINT64_C(0xb7af7fff00000000)),
                          vcreate_s16(UINT64_C(0x00007fff6a9c7ecb)));
      clear_neon_saturated();
      //  Expect: "result" = 45d900011563813442a3000180008000
      result = vsubq_s16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 0);
         exp = UINT64_C(0x42a3000180008000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 1);
         exp = UINT64_C(0x45d9000115638134);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_290() {

{
   {
      int32x4_t arg1;
      int32x4_t arg2;
      int32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"sub\", fnname = \"vsubq_s32\", rettype = \"int32x4_t\", argtypes = \"[int32x4_t,int32x4_t]\", vals = [VectorVal [IntegerVal 2147483647,IntegerVal 56519,IntegerVal (-32768),IntegerVal 65535],VectorVal [IntegerVal (-413794304),IntegerVal (-2147450880),IntegerVal 1679479345,IntegerVal 2147450879]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s32(vcreate_s32(UINT64_C(0x0000dcc77fffffff)),
                          vcreate_s32(UINT64_C(0x0000ffffffff8000)));
      arg2 = vcombine_s32(vcreate_s32(UINT64_C(0x80008000e7560000)),
                          vcreate_s32(UINT64_C(0x7fff7fff641ad231)));
      clear_neon_saturated();
      //  Expect: "result" = 800180009be4adcf80005cc798a9ffff
      result = vsubq_s32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 0);
         exp = UINT64_C(0x80005cc798a9ffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 1);
         exp = UINT64_C(0x800180009be4adcf);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_291() {

{
   {
      int64x2_t arg1;
      int64x2_t arg2;
      int64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"sub\", fnname = \"vsubq_s64\", rettype = \"int64x2_t\", argtypes = \"[int64x2_t,int64x2_t]\", vals = [VectorVal [IntegerVal 140737488360065,IntegerVal (-281474976677888)],VectorVal [IntegerVal (-9223231295071453185),IntegerVal 281474976677887]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s64(vcreate_s64(UINT64_C(0x0000800000001281)),
                          vcreate_s64(UINT64_C(0xffff000000008000)));
      arg2 = vcombine_s64(vcreate_s64(UINT64_C(0x80008000ffffffff)),
                          vcreate_s64(UINT64_C(0x0000ffffffff7fff)));
      clear_neon_saturated();
      //  Expect: "result" = fffe0000000100017fffffff00001282
      result = vsubq_s64(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 0);
         exp = UINT64_C(0x7fffffff00001282);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 1);
         exp = UINT64_C(0xfffe000000010001);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_292() {

{
   {
      float32x4_t arg1;
      float32x4_t arg2;
      float32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"sub\", fnname = \"vsubq_f32\", rettype = \"float32x4_t\", argtypes = \"[float32x4_t,float32x4_t]\", vals = [VectorVal [FloatVal 0.805039644241333,FloatVal 0.8142534494400024,FloatVal 0.31933683156967163,FloatVal 1.9804537296295166e-2],VectorVal [FloatVal 0.43983978033065796,FloatVal 0.8844547867774963,FloatVal 0.375455379486084,FloatVal 0.6776692867279053]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_f32(vcreate_f32(UINT64_C(0x3f5072ea3f4e1714)),
                          vcreate_f32(UINT64_C(0x3ca23d203ea3801e)));
      arg2 = vcombine_f32(vcreate_f32(UINT64_C(0x3f626ba13ee132ae)),
                          vcreate_f32(UINT64_C(0x3f2d7bbc3ec03bb0)));
      clear_neon_saturated();
      //  Expect: "result" = bf2869d3bd65dc90bd8fc5b83ebafb7a
      result = vsubq_f32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 0);
         exp = ((float32_t) 0.36519986391067505);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 1);
         exp = ((float32_t) -7.02013373374939e-2);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 2);
         exp = ((float32_t) -5.6118547916412354e-2);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 2 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 3);
         exp = ((float32_t) -0.6578647494316101);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 3 ", exp, got);
            }
      }
   }
}
}
void dotests_293() {

{
   {
      uint8x16_t arg1;
      uint8x16_t arg2;
      uint8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"sub\", fnname = \"vsubq_u8\", rettype = \"uint8x16_t\", argtypes = \"[uint8x16_t,uint8x16_t]\", vals = [VectorVal [IntegerVal 127,IntegerVal 21,IntegerVal 20,IntegerVal 13,IntegerVal 210,IntegerVal 127,IntegerVal 128,IntegerVal 182,IntegerVal 66,IntegerVal 255,IntegerVal 255,IntegerVal 0,IntegerVal 0,IntegerVal 87,IntegerVal 200,IntegerVal 255],VectorVal [IntegerVal 0,IntegerVal 127,IntegerVal 127,IntegerVal 127,IntegerVal 153,IntegerVal 127,IntegerVal 127,IntegerVal 172,IntegerVal 29,IntegerVal 64,IntegerVal 127,IntegerVal 128,IntegerVal 139,IntegerVal 0,IntegerVal 128,IntegerVal 128]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u8(vcreate_u8(UINT64_C(0xb6807fd20d14157f)),
                         vcreate_u8(UINT64_C(0xffc8570000ffff42)));
      arg2 = vcombine_u8(vcreate_u8(UINT64_C(0xac7f7f997f7f7f00)),
                         vcreate_u8(UINT64_C(0x8080008b807f401d)));
      clear_neon_saturated();
      //  Expect: "result" = 7f4857758080bf250a0100398e95967f
      result = vsubq_u8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 0);
         exp = UINT64_C(0x0a0100398e95967f);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 1);
         exp = UINT64_C(0x7f4857758080bf25);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_294() {

{
   {
      uint16x8_t arg1;
      uint16x8_t arg2;
      uint16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"sub\", fnname = \"vsubq_u16\", rettype = \"uint16x8_t\", argtypes = \"[uint16x8_t,uint16x8_t]\", vals = [VectorVal [IntegerVal 0,IntegerVal 65535,IntegerVal 0,IntegerVal 0,IntegerVal 32768,IntegerVal 32768,IntegerVal 32768,IntegerVal 32768],VectorVal [IntegerVal 39398,IntegerVal 65535,IntegerVal 0,IntegerVal 56883,IntegerVal 65535,IntegerVal 32768,IntegerVal 0,IntegerVal 11324]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u16(vcreate_u16(UINT64_C(0x00000000ffff0000)),
                          vcreate_u16(UINT64_C(0x8000800080008000)));
      arg2 = vcombine_u16(vcreate_u16(UINT64_C(0xde330000ffff99e6)),
                          vcreate_u16(UINT64_C(0x2c3c00008000ffff)));
      clear_neon_saturated();
      //  Expect: "result" = 53c480000000800121cd00000000661a
      result = vsubq_u16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 0);
         exp = UINT64_C(0x21cd00000000661a);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 1);
         exp = UINT64_C(0x53c4800000008001);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_295() {

{
   {
      uint32x4_t arg1;
      uint32x4_t arg2;
      uint32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"sub\", fnname = \"vsubq_u32\", rettype = \"uint32x4_t\", argtypes = \"[uint32x4_t,uint32x4_t]\", vals = [VectorVal [IntegerVal 2147483647,IntegerVal 2147450879,IntegerVal 2147516415,IntegerVal 13639],VectorVal [IntegerVal 2734177468,IntegerVal 32768,IntegerVal 2147516415,IntegerVal 32767]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u32(vcreate_u32(UINT64_C(0x7fff7fff7fffffff)),
                          vcreate_u32(UINT64_C(0x0000354780007fff)));
      arg2 = vcombine_u32(vcreate_u32(UINT64_C(0x00008000a2f83cbc)),
                          vcreate_u32(UINT64_C(0x00007fff80007fff)));
      clear_neon_saturated();
      //  Expect: "result" = ffffb548000000007ffeffffdd07c343
      result = vsubq_u32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 0);
         exp = UINT64_C(0x7ffeffffdd07c343);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 1);
         exp = UINT64_C(0xffffb54800000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_296() {

{
   {
      uint64x2_t arg1;
      uint64x2_t arg2;
      uint64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"sub\", fnname = \"vsubq_u64\", rettype = \"uint64x2_t\", argtypes = \"[uint64x2_t,uint64x2_t]\", vals = [VectorVal [IntegerVal 281472829194239,IntegerVal 2238429752291491840],VectorVal [IntegerVal 18446744069414617087,IntegerVal 9223101646737859685]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u64(vcreate_u64(UINT64_C(0x0000ffff7fff7fff)),
                          vcreate_u64(UINT64_C(0x1f10800000000000)));
      arg2 = vcombine_u64(vcreate_u64(UINT64_C(0xffffffff00007fff)),
                          vcreate_u64(UINT64_C(0x7fff0a14e5216465)));
      clear_neon_saturated();
      //  Expect: "result" = 9f1175eb1ade9b9b000100007fff0000
      result = vsubq_u64(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 0);
         exp = UINT64_C(0x000100007fff0000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 1);
         exp = UINT64_C(0x9f1175eb1ade9b9b);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_297() {

{
   {
      float64x1_t arg1;
      float64x1_t arg2;
      float64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"sub\", fnname = \"vsub_f64\", rettype = \"float64x1_t\", argtypes = \"[float64x1_t,float64x1_t]\", vals = [VectorVal [FloatVal 0.5843540769789802],VectorVal [FloatVal 0.3586207257152022]], start_saturated = False}";
      int reported = 0;
      float64_t got;
      float64_t exp;
      arg1 = vcreate_f64(UINT64_C(0x3fe2b307523d166b));
      arg2 = vcreate_f64(UINT64_C(0x3fd6f3a458275546));
      clear_neon_saturated();
      //  Expect: "result" = 3fcce4d498a5af20
      result = vsub_f64(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_f64(result, 0);
      exp = 0.22573335126377803;
      if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
         }
   }
}
}
void dotests_298() {

{
   {
      float64x2_t arg1;
      float64x2_t arg2;
      float64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"sub\", fnname = \"vsubq_f64\", rettype = \"float64x2_t\", argtypes = \"[float64x2_t,float64x2_t]\", vals = [VectorVal [FloatVal 0.2204200279093601,FloatVal 0.33492918569927255],VectorVal [FloatVal 0.6584738349037559,FloatVal 0.17379582216196376]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_f64(vcreate_f64(UINT64_C(0x3fcc36b935a086a4)),
                          vcreate_f64(UINT64_C(0x3fd56f7ad2c3796e)));
      arg2 = vcombine_f64(vcreate_f64(UINT64_C(0x3fe51237b845dde1)),
                          vcreate_f64(UINT64_C(0x3fc63ef1062efc08)));
      clear_neon_saturated();
      //  Expect: "result" = 3fc4a0049f57f6d4bfdc0912d5bb7870
      result = vsubq_f64(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float64_t got;
         float64_t exp;
         got = vgetq_lane_f64(result, 0);
         exp = -0.4380538069943958;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float64_t got;
         float64_t exp;
         got = vgetq_lane_f64(result, 1);
         exp = 0.16113336353730878;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
   }
}
}
void dotests_299() {

{
   {
      int64_t arg1;
      int64_t arg2;
      int64_t result;
      char* str1 = "ReproInfo2 {semantics = \"sub\", fnname = \"vsubd_s64\", rettype = \"int64_t\", argtypes = \"[int64_t,int64_t]\", vals = [IntegerVal (-9223090564398678017),IntegerVal 1314769614067990527], start_saturated = False}";
      int reported = 0;
      int64_t got;
      int64_t exp;
      arg1 = INT64_C(-9223090564398678017);
      arg2 = INT64_C(1314769614067990527);
      clear_neon_saturated();
      //  Expect: "result" = 6dc1ffffe9c28000
      result = vsubd_s64(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = INT64_C(7908883895242883072);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIi64 " Got: %" PRIi64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_300() {

{
   {
      uint64_t arg1;
      uint64_t arg2;
      uint64_t result;
      char* str1 = "ReproInfo2 {semantics = \"sub\", fnname = \"vsubd_u64\", rettype = \"uint64_t\", argtypes = \"[uint64_t,uint64_t]\", vals = [IntegerVal 9223653509787396097,IntegerVal 9223372040262647807], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = UINT64_C(0x8000ffff8629a801);
      arg2 = UINT64_C(0x80000000cb1fffff);
      clear_neon_saturated();
      //  Expect: "result" = 0000fffebb09a802
      result = vsubd_u64(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = UINT64_C(0x0000fffebb09a802);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_301() {

{
   {
      int8x8_t arg1;
      int8x8_t arg2;
      int16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"sub\", fnname = \"vsubl_s8\", rettype = \"int16x8_t\", argtypes = \"[int8x8_t,int8x8_t]\", vals = [VectorVal [IntegerVal (-128),IntegerVal (-128),IntegerVal (-1),IntegerVal 0,IntegerVal 0,IntegerVal 0,IntegerVal 127,IntegerVal 0],VectorVal [IntegerVal 9,IntegerVal 0,IntegerVal 127,IntegerVal 0,IntegerVal (-93),IntegerVal (-1),IntegerVal (-1),IntegerVal (-42)]], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_s8(UINT64_C(0x007f000000ff8080));
      arg2 = vcreate_s8(UINT64_C(0xd6ffffa3007f0009));
      clear_neon_saturated();
      //  Expect: "result" = 002a00800001005d0000ff80ff80ff77
      result = vsubl_s8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 0);
         exp = UINT64_C(0x0000ff80ff80ff77);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 1);
         exp = UINT64_C(0x002a00800001005d);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_302() {

{
   {
      int16x4_t arg1;
      int16x4_t arg2;
      int32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"sub\", fnname = \"vsubl_s16\", rettype = \"int32x4_t\", argtypes = \"[int16x4_t,int16x4_t]\", vals = [VectorVal [IntegerVal (-32768),IntegerVal 32767,IntegerVal 32767,IntegerVal 32767],VectorVal [IntegerVal 0,IntegerVal 20272,IntegerVal 27842,IntegerVal (-1)]], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_s16(UINT64_C(0x7fff7fff7fff8000));
      arg2 = vcreate_s16(UINT64_C(0xffff6cc24f300000));
      clear_neon_saturated();
      //  Expect: "result" = 000080000000133d000030cfffff8000
      result = vsubl_s16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 0);
         exp = UINT64_C(0x000030cfffff8000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 1);
         exp = UINT64_C(0x000080000000133d);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_303() {

{
   {
      int32x2_t arg1;
      int32x2_t arg2;
      int64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"sub\", fnname = \"vsubl_s32\", rettype = \"int64x2_t\", argtypes = \"[int32x2_t,int32x2_t]\", vals = [VectorVal [IntegerVal (-32769),IntegerVal 0],VectorVal [IntegerVal 15109,IntegerVal (-2147418113)]], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_s32(UINT64_C(0x00000000ffff7fff));
      arg2 = vcreate_s32(UINT64_C(0x8000ffff00003b05));
      clear_neon_saturated();
      //  Expect: "result" = 000000007fff0001ffffffffffff44fa
      result = vsubl_s32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 0);
         exp = UINT64_C(0xffffffffffff44fa);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 1);
         exp = UINT64_C(0x000000007fff0001);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_304() {

{
   {
      uint8x8_t arg1;
      uint8x8_t arg2;
      uint16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"sub\", fnname = \"vsubl_u8\", rettype = \"uint16x8_t\", argtypes = \"[uint8x8_t,uint8x8_t]\", vals = [VectorVal [IntegerVal 108,IntegerVal 128,IntegerVal 0,IntegerVal 20,IntegerVal 204,IntegerVal 0,IntegerVal 69,IntegerVal 0],VectorVal [IntegerVal 0,IntegerVal 128,IntegerVal 128,IntegerVal 7,IntegerVal 128,IntegerVal 127,IntegerVal 95,IntegerVal 160]], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_u8(UINT64_C(0x004500cc1400806c));
      arg2 = vcreate_u8(UINT64_C(0xa05f7f8007808000));
      clear_neon_saturated();
      //  Expect: "result" = ff60ffe6ff81004c000dff800000006c
      result = vsubl_u8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 0);
         exp = UINT64_C(0x000dff800000006c);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 1);
         exp = UINT64_C(0xff60ffe6ff81004c);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_305() {

{
   {
      uint16x4_t arg1;
      uint16x4_t arg2;
      uint32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"sub\", fnname = \"vsubl_u16\", rettype = \"uint32x4_t\", argtypes = \"[uint16x4_t,uint16x4_t]\", vals = [VectorVal [IntegerVal 60683,IntegerVal 65535,IntegerVal 0,IntegerVal 0],VectorVal [IntegerVal 65535,IntegerVal 0,IntegerVal 0,IntegerVal 32768]], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_u16(UINT64_C(0x00000000ffffed0b));
      arg2 = vcreate_u16(UINT64_C(0x800000000000ffff));
      clear_neon_saturated();
      //  Expect: "result" = ffff8000000000000000ffffffffed0c
      result = vsubl_u16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 0);
         exp = UINT64_C(0x0000ffffffffed0c);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 1);
         exp = UINT64_C(0xffff800000000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_306() {

{
   {
      uint32x2_t arg1;
      uint32x2_t arg2;
      uint64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"sub\", fnname = \"vsubl_u32\", rettype = \"uint64x2_t\", argtypes = \"[uint32x2_t,uint32x2_t]\", vals = [VectorVal [IntegerVal 4294967295,IntegerVal 2147482202],VectorVal [IntegerVal 2247950335,IntegerVal 2147516416]], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_u32(UINT64_C(0x7ffffa5affffffff));
      arg2 = vcreate_u32(UINT64_C(0x8000800085fcffff));
      clear_neon_saturated();
      //  Expect: "result" = ffffffffffff7a5a000000007a030000
      result = vsubl_u32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 0);
         exp = UINT64_C(0x000000007a030000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 1);
         exp = UINT64_C(0xffffffffffff7a5a);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_307() {

{
   {
      int8x16_t arg1;
      int8x16_t arg2;
      int16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"sub\", fnname = \"vsubl_high_s8\", rettype = \"int16x8_t\", argtypes = \"[int8x16_t,int8x16_t]\", vals = [VectorVal [IntegerVal 120,IntegerVal 0,IntegerVal 0,IntegerVal (-128),IntegerVal (-88),IntegerVal (-1),IntegerVal 0,IntegerVal (-128),IntegerVal (-128),IntegerVal 127,IntegerVal (-1),IntegerVal 6,IntegerVal 0,IntegerVal 0,IntegerVal 0,IntegerVal 127],VectorVal [IntegerVal (-69),IntegerVal (-1),IntegerVal 0,IntegerVal 127,IntegerVal 0,IntegerVal (-128),IntegerVal 0,IntegerVal 127,IntegerVal (-128),IntegerVal 127,IntegerVal (-128),IntegerVal (-128),IntegerVal 127,IntegerVal 116,IntegerVal (-128),IntegerVal 0]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s8(vcreate_s8(UINT64_C(0x8000ffa880000078)),
                         vcreate_s8(UINT64_C(0x7f00000006ff7f80)));
      arg2 = vcombine_s8(vcreate_s8(UINT64_C(0x7f0080007f00ffbb)),
                         vcreate_s8(UINT64_C(0x0080747f80807f80)));
      clear_neon_saturated();
      //  Expect: "result" = 007f0080ff8cff810086007f00000000
      result = vsubl_high_s8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 0);
         exp = UINT64_C(0x0086007f00000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 1);
         exp = UINT64_C(0x007f0080ff8cff81);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_308() {

{
   {
      int16x8_t arg1;
      int16x8_t arg2;
      int32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"sub\", fnname = \"vsubl_high_s16\", rettype = \"int32x4_t\", argtypes = \"[int16x8_t,int16x8_t]\", vals = [VectorVal [IntegerVal (-32768),IntegerVal 32767,IntegerVal (-32768),IntegerVal (-32768),IntegerVal 32767,IntegerVal (-28030),IntegerVal (-32768),IntegerVal 0],VectorVal [IntegerVal 0,IntegerVal 32767,IntegerVal 10851,IntegerVal 32767,IntegerVal (-29254),IntegerVal (-32768),IntegerVal 0,IntegerVal 0]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s16(vcreate_s16(UINT64_C(0x800080007fff8000)),
                          vcreate_s16(UINT64_C(0x0000800092827fff)));
      arg2 = vcombine_s16(vcreate_s16(UINT64_C(0x7fff2a637fff0000)),
                          vcreate_s16(UINT64_C(0x0000000080008dba)));
      clear_neon_saturated();
      //  Expect: "result" = 00000000ffff8000000012820000f245
      result = vsubl_high_s16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 0);
         exp = UINT64_C(0x000012820000f245);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 1);
         exp = UINT64_C(0x00000000ffff8000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_309() {

{
   {
      int32x4_t arg1;
      int32x4_t arg2;
      int64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"sub\", fnname = \"vsubl_high_s32\", rettype = \"int64x2_t\", argtypes = \"[int32x4_t,int32x4_t]\", vals = [VectorVal [IntegerVal (-1959919617),IntegerVal 2147464108,IntegerVal (-1),IntegerVal (-32769)],VectorVal [IntegerVal (-28107),IntegerVal (-65536),IntegerVal (-32768),IntegerVal 2147450880]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s32(vcreate_s32(UINT64_C(0x7fffb3ac8b2dffff)),
                          vcreate_s32(UINT64_C(0xffff7fffffffffff)));
      arg2 = vcombine_s32(vcreate_s32(UINT64_C(0xffff0000ffff9235)),
                          vcreate_s32(UINT64_C(0x7fff8000ffff8000)));
      clear_neon_saturated();
      //  Expect: "result" = ffffffff7fffffff0000000000007fff
      result = vsubl_high_s32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 0);
         exp = UINT64_C(0x0000000000007fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 1);
         exp = UINT64_C(0xffffffff7fffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_310() {

{
   {
      uint8x16_t arg1;
      uint8x16_t arg2;
      uint16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"sub\", fnname = \"vsubl_high_u8\", rettype = \"uint16x8_t\", argtypes = \"[uint8x16_t,uint8x16_t]\", vals = [VectorVal [IntegerVal 0,IntegerVal 127,IntegerVal 127,IntegerVal 127,IntegerVal 0,IntegerVal 127,IntegerVal 255,IntegerVal 211,IntegerVal 128,IntegerVal 127,IntegerVal 184,IntegerVal 227,IntegerVal 255,IntegerVal 128,IntegerVal 128,IntegerVal 149],VectorVal [IntegerVal 0,IntegerVal 127,IntegerVal 128,IntegerVal 0,IntegerVal 0,IntegerVal 127,IntegerVal 255,IntegerVal 255,IntegerVal 75,IntegerVal 255,IntegerVal 127,IntegerVal 127,IntegerVal 0,IntegerVal 221,IntegerVal 0,IntegerVal 128]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u8(vcreate_u8(UINT64_C(0xd3ff7f007f7f7f00)),
                         vcreate_u8(UINT64_C(0x958080ffe3b87f80)));
      arg2 = vcombine_u8(vcreate_u8(UINT64_C(0xffff7f0000807f00)),
                         vcreate_u8(UINT64_C(0x8000dd007f7fff4b)));
      clear_neon_saturated();
      //  Expect: "result" = 00150080ffa300ff00640039ff800035
      result = vsubl_high_u8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 0);
         exp = UINT64_C(0x00640039ff800035);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 1);
         exp = UINT64_C(0x00150080ffa300ff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_311() {

{
   {
      uint16x8_t arg1;
      uint16x8_t arg2;
      uint32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"sub\", fnname = \"vsubl_high_u16\", rettype = \"uint32x4_t\", argtypes = \"[uint16x8_t,uint16x8_t]\", vals = [VectorVal [IntegerVal 32768,IntegerVal 52680,IntegerVal 65535,IntegerVal 65535,IntegerVal 0,IntegerVal 32767,IntegerVal 65535,IntegerVal 32767],VectorVal [IntegerVal 65535,IntegerVal 32767,IntegerVal 32768,IntegerVal 32768,IntegerVal 0,IntegerVal 32767,IntegerVal 65419,IntegerVal 43954]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u16(vcreate_u16(UINT64_C(0xffffffffcdc88000)),
                          vcreate_u16(UINT64_C(0x7fffffff7fff0000)));
      arg2 = vcombine_u16(vcreate_u16(UINT64_C(0x800080007fffffff)),
                          vcreate_u16(UINT64_C(0xabb2ff8b7fff0000)));
      clear_neon_saturated();
      //  Expect: "result" = ffffd44d000000740000000000000000
      result = vsubl_high_u16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 0);
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 1);
         exp = UINT64_C(0xffffd44d00000074);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_312() {

{
   {
      uint32x4_t arg1;
      uint32x4_t arg2;
      uint64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"sub\", fnname = \"vsubl_high_u32\", rettype = \"uint64x2_t\", argtypes = \"[uint32x4_t,uint32x4_t]\", vals = [VectorVal [IntegerVal 4294967295,IntegerVal 2147450880,IntegerVal 2147516416,IntegerVal 1529348096],VectorVal [IntegerVal 2147516416,IntegerVal 52955,IntegerVal 4294901760,IntegerVal 2147453221]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u32(vcreate_u32(UINT64_C(0x7fff8000ffffffff)),
                          vcreate_u32(UINT64_C(0x5b28000080008000)));
      arg2 = vcombine_u32(vcreate_u32(UINT64_C(0x0000cedb80008000)),
                          vcreate_u32(UINT64_C(0x7fff8925ffff0000)));
      clear_neon_saturated();
      //  Expect: "result" = ffffffffdb2876dbffffffff80018000
      result = vsubl_high_u32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 0);
         exp = UINT64_C(0xffffffff80018000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 1);
         exp = UINT64_C(0xffffffffdb2876db);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_313() {

{
   {
      int16x8_t arg1;
      int8x8_t arg2;
      int16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"sub\", fnname = \"vsubw_s8\", rettype = \"int16x8_t\", argtypes = \"[int16x8_t,int8x8_t]\", vals = [VectorVal [IntegerVal (-1),IntegerVal 32767,IntegerVal (-32768),IntegerVal 32767,IntegerVal (-32768),IntegerVal 32767,IntegerVal (-32768),IntegerVal (-32768)],VectorVal [IntegerVal (-128),IntegerVal (-1),IntegerVal 0,IntegerVal (-74),IntegerVal (-128),IntegerVal (-1),IntegerVal 81,IntegerVal (-128)]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s16(vcreate_s16(UINT64_C(0x7fff80007fffffff)),
                          vcreate_s16(UINT64_C(0x800080007fff8000)));
      arg2 = vcreate_s8(UINT64_C(0x8051ff80b600ff80));
      clear_neon_saturated();
      //  Expect: "result" = 80807faf80008080804980008000007f
      result = vsubw_s8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 0);
         exp = UINT64_C(0x804980008000007f);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 1);
         exp = UINT64_C(0x80807faf80008080);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_314() {

{
   {
      int32x4_t arg1;
      int16x4_t arg2;
      int32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"sub\", fnname = \"vsubw_s16\", rettype = \"int32x4_t\", argtypes = \"[int32x4_t,int16x4_t]\", vals = [VectorVal [IntegerVal (-32769),IntegerVal 2147483647,IntegerVal 32767,IntegerVal (-2147483648)],VectorVal [IntegerVal (-32768),IntegerVal (-1),IntegerVal (-32768),IntegerVal (-32768)]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s32(vcreate_s32(UINT64_C(0x7fffffffffff7fff)),
                          vcreate_s32(UINT64_C(0x8000000000007fff)));
      arg2 = vcreate_s16(UINT64_C(0x80008000ffff8000));
      clear_neon_saturated();
      //  Expect: "result" = 800080000000ffff80000000ffffffff
      result = vsubw_s16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 0);
         exp = UINT64_C(0x80000000ffffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 1);
         exp = UINT64_C(0x800080000000ffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_315() {

{
   {
      int64x2_t arg1;
      int32x2_t arg2;
      int64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"sub\", fnname = \"vsubw_s32\", rettype = \"int64x2_t\", argtypes = \"[int64x2_t,int32x2_t]\", vals = [VectorVal [IntegerVal 4552013323364663296,IntegerVal (-4294934351)],VectorVal [IntegerVal 2147451168,IntegerVal 0]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s64(vcreate_s64(UINT64_C(0x3f2bffffffff0000)),
                          vcreate_s64(UINT64_C(0xffffffff000080b1)));
      arg2 = vcreate_s32(UINT64_C(0x000000007fff8120));
      clear_neon_saturated();
      //  Expect: "result" = ffffffff000080b13f2bffff7fff7ee0
      result = vsubw_s32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 0);
         exp = UINT64_C(0x3f2bffff7fff7ee0);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 1);
         exp = UINT64_C(0xffffffff000080b1);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_316() {

{
   {
      uint16x8_t arg1;
      uint8x8_t arg2;
      uint16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"sub\", fnname = \"vsubw_u8\", rettype = \"uint16x8_t\", argtypes = \"[uint16x8_t,uint8x8_t]\", vals = [VectorVal [IntegerVal 44764,IntegerVal 65535,IntegerVal 27124,IntegerVal 5209,IntegerVal 65535,IntegerVal 0,IntegerVal 32767,IntegerVal 65535],VectorVal [IntegerVal 32,IntegerVal 128,IntegerVal 128,IntegerVal 127,IntegerVal 0,IntegerVal 0,IntegerVal 128,IntegerVal 128]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u16(vcreate_u16(UINT64_C(0x145969f4ffffaedc)),
                          vcreate_u16(UINT64_C(0xffff7fff0000ffff)));
      arg2 = vcreate_u8(UINT64_C(0x808000007f808020));
      clear_neon_saturated();
      //  Expect: "result" = ff7f7f7f0000ffff13da6974ff7faebc
      result = vsubw_u8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 0);
         exp = UINT64_C(0x13da6974ff7faebc);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 1);
         exp = UINT64_C(0xff7f7f7f0000ffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_317() {

{
   {
      uint32x4_t arg1;
      uint16x4_t arg2;
      uint32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"sub\", fnname = \"vsubw_u16\", rettype = \"uint32x4_t\", argtypes = \"[uint32x4_t,uint16x4_t]\", vals = [VectorVal [IntegerVal 2147450879,IntegerVal 2147483647,IntegerVal 2147516415,IntegerVal 65535],VectorVal [IntegerVal 9511,IntegerVal 32768,IntegerVal 32768,IntegerVal 0]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u32(vcreate_u32(UINT64_C(0x7fffffff7fff7fff)),
                          vcreate_u32(UINT64_C(0x0000ffff80007fff)));
      arg2 = vcreate_u16(UINT64_C(0x0000800080002527));
      clear_neon_saturated();
      //  Expect: "result" = 0000ffff7fffffff7fff7fff7fff5ad8
      result = vsubw_u16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 0);
         exp = UINT64_C(0x7fff7fff7fff5ad8);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 1);
         exp = UINT64_C(0x0000ffff7fffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_318() {

{
   {
      uint64x2_t arg1;
      uint32x2_t arg2;
      uint64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"sub\", fnname = \"vsubw_u32\", rettype = \"uint64x2_t\", argtypes = \"[uint64x2_t,uint32x2_t]\", vals = [VectorVal [IntegerVal 463870763392663551,IntegerVal 18446462600880390143],VectorVal [IntegerVal 0,IntegerVal 4294944381]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u64(vcreate_u64(UINT64_C(0x0670000069b57fff)),
                          vcreate_u64(UINT64_C(0xffff00008000ffff)));
      arg2 = vcreate_u32(UINT64_C(0xffffa67d00000000));
      clear_neon_saturated();
      //  Expect: "result" = fffeffff800159820670000069b57fff
      result = vsubw_u32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 0);
         exp = UINT64_C(0x0670000069b57fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 1);
         exp = UINT64_C(0xfffeffff80015982);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_319() {

{
   {
      int16x8_t arg1;
      int8x16_t arg2;
      int16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"sub\", fnname = \"vsubw_high_s8\", rettype = \"int16x8_t\", argtypes = \"[int16x8_t,int8x16_t]\", vals = [VectorVal [IntegerVal (-1),IntegerVal 32767,IntegerVal (-1),IntegerVal (-32768),IntegerVal (-32768),IntegerVal (-32768),IntegerVal (-1),IntegerVal 32767],VectorVal [IntegerVal 0,IntegerVal (-1),IntegerVal (-128),IntegerVal (-1),IntegerVal 127,IntegerVal (-54),IntegerVal 0,IntegerVal (-1),IntegerVal 39,IntegerVal 0,IntegerVal 0,IntegerVal (-87),IntegerVal (-1),IntegerVal (-1),IntegerVal (-128),IntegerVal 127]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s16(vcreate_s16(UINT64_C(0x8000ffff7fffffff)),
                          vcreate_s16(UINT64_C(0x7fffffff80008000)));
      arg2 = vcombine_s8(vcreate_s8(UINT64_C(0xff00ca7fff80ff00)),
                         vcreate_s8(UINT64_C(0x7f80ffffa9000027)));
      clear_neon_saturated();
      //  Expect: "result" = 7f80007f800180018057ffff7fffffd8
      result = vsubw_high_s8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 0);
         exp = UINT64_C(0x8057ffff7fffffd8);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 1);
         exp = UINT64_C(0x7f80007f80018001);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_320() {

{
   {
      int32x4_t arg1;
      int16x8_t arg2;
      int32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"sub\", fnname = \"vsubw_high_s16\", rettype = \"int32x4_t\", argtypes = \"[int32x4_t,int16x8_t]\", vals = [VectorVal [IntegerVal (-52363264),IntegerVal (-2147428582),IntegerVal (-32768),IntegerVal 32768],VectorVal [IntegerVal (-20535),IntegerVal 32767,IntegerVal 0,IntegerVal 32767,IntegerVal 32767,IntegerVal 22927,IntegerVal (-1),IntegerVal 24388]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s32(vcreate_s32(UINT64_C(0x8000d71afce10000)),
                          vcreate_s32(UINT64_C(0x00008000ffff8000)));
      arg2 = vcombine_s16(vcreate_s16(UINT64_C(0x7fff00007fffafc9)),
                          vcreate_s16(UINT64_C(0x5f44ffff598f7fff)));
      clear_neon_saturated();
      //  Expect: "result" = 000020bcffff800180007d8bfce08001
      result = vsubw_high_s16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 0);
         exp = UINT64_C(0x80007d8bfce08001);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 1);
         exp = UINT64_C(0x000020bcffff8001);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_321() {

{
   {
      int64x2_t arg1;
      int32x4_t arg2;
      int64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"sub\", fnname = \"vsubw_high_s32\", rettype = \"int64x2_t\", argtypes = \"[int64x2_t,int32x4_t]\", vals = [VectorVal [IntegerVal (-9223231301513838593),IntegerVal (-281472829284228)],VectorVal [IntegerVal 2147418112,IntegerVal 65535,IntegerVal (-2147450881),IntegerVal 2147483647]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s64(vcreate_s64(UINT64_C(0x80007fff8000ffff)),
                          vcreate_s64(UINT64_C(0xffff00007fff207c)));
      arg2 = vcombine_s32(vcreate_s32(UINT64_C(0x0000ffff7fff0000)),
                          vcreate_s32(UINT64_C(0x7fffffff80007fff)));
      clear_neon_saturated();
      //  Expect: "result" = fffeffffffff207d8000800000008000
      result = vsubw_high_s32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 0);
         exp = UINT64_C(0x8000800000008000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 1);
         exp = UINT64_C(0xfffeffffffff207d);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_322() {

{
   {
      uint16x8_t arg1;
      uint8x16_t arg2;
      uint16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"sub\", fnname = \"vsubw_high_u8\", rettype = \"uint16x8_t\", argtypes = \"[uint16x8_t,uint8x16_t]\", vals = [VectorVal [IntegerVal 32767,IntegerVal 32768,IntegerVal 55834,IntegerVal 4593,IntegerVal 0,IntegerVal 0,IntegerVal 0,IntegerVal 32767],VectorVal [IntegerVal 255,IntegerVal 0,IntegerVal 100,IntegerVal 255,IntegerVal 255,IntegerVal 127,IntegerVal 128,IntegerVal 255,IntegerVal 255,IntegerVal 152,IntegerVal 128,IntegerVal 0,IntegerVal 128,IntegerVal 128,IntegerVal 255,IntegerVal 127]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u16(vcreate_u16(UINT64_C(0x11f1da1a80007fff)),
                          vcreate_u16(UINT64_C(0x7fff000000000000)));
      arg2 = vcombine_u8(vcreate_u8(UINT64_C(0xff807fffff6400ff)),
                         vcreate_u8(UINT64_C(0x7fff8080008098ff)));
      clear_neon_saturated();
      //  Expect: "result" = 7f80ff01ff80ff8011f1d99a7f687f00
      result = vsubw_high_u8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 0);
         exp = UINT64_C(0x11f1d99a7f687f00);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 1);
         exp = UINT64_C(0x7f80ff01ff80ff80);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_323() {

{
   {
      uint32x4_t arg1;
      uint16x8_t arg2;
      uint32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"sub\", fnname = \"vsubw_high_u16\", rettype = \"uint32x4_t\", argtypes = \"[uint32x4_t,uint16x8_t]\", vals = [VectorVal [IntegerVal 4294967295,IntegerVal 2147450879,IntegerVal 2147516416,IntegerVal 4294934527],VectorVal [IntegerVal 37812,IntegerVal 0,IntegerVal 65535,IntegerVal 32768,IntegerVal 65535,IntegerVal 0,IntegerVal 0,IntegerVal 32768]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u32(vcreate_u32(UINT64_C(0x7fff7fffffffffff)),
                          vcreate_u32(UINT64_C(0xffff7fff80008000)));
      arg2 = vcombine_u16(vcreate_u16(UINT64_C(0x8000ffff000093b4)),
                          vcreate_u16(UINT64_C(0x800000000000ffff)));
      clear_neon_saturated();
      //  Expect: "result" = fffeffff800080007fff7fffffff0000
      result = vsubw_high_u16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 0);
         exp = UINT64_C(0x7fff7fffffff0000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 1);
         exp = UINT64_C(0xfffeffff80008000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_324() {

{
   {
      uint64x2_t arg1;
      uint32x4_t arg2;
      uint64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"sub\", fnname = \"vsubw_high_u32\", rettype = \"uint64x2_t\", argtypes = \"[uint64x2_t,uint32x4_t]\", vals = [VectorVal [IntegerVal 9223372034707303286,IntegerVal 140739635806208],VectorVal [IntegerVal 2147549183,IntegerVal 4294934528,IntegerVal 4294934528,IntegerVal 47567]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u64(vcreate_u64(UINT64_C(0x7fffffff80002b76)),
                          vcreate_u64(UINT64_C(0x000080007fff8000)));
      arg2 = vcombine_u32(vcreate_u32(UINT64_C(0xffff80008000ffff)),
                          vcreate_u32(UINT64_C(0x0000b9cfffff8000)));
      clear_neon_saturated();
      //  Expect: "result" = 000080007ffec6317ffffffe8000ab76
      result = vsubw_high_u32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 0);
         exp = UINT64_C(0x7ffffffe8000ab76);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 1);
         exp = UINT64_C(0x000080007ffec631);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_325() {

{
   {
      int8x8_t arg1;
      int8x8_t arg2;
      int8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"saturating_sub\", fnname = \"vqsub_s8\", rettype = \"int8x8_t\", argtypes = \"[int8x8_t,int8x8_t]\", vals = [VectorVal [IntegerVal (-1),IntegerVal 0,IntegerVal (-128),IntegerVal 0,IntegerVal (-5),IntegerVal 127,IntegerVal (-1),IntegerVal (-1)],VectorVal [IntegerVal 127,IntegerVal (-1),IntegerVal 0,IntegerVal 127,IntegerVal 0,IntegerVal 127,IntegerVal (-1),IntegerVal 0]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s8(UINT64_C(0xffff7ffb008000ff));
      arg2 = vcreate_s8(UINT64_C(0x00ff7f007f00ff7f));
      clear_neon_saturated();
      //  Expect: "result" = ff0000fb81800180
      result = vqsub_s8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s8(result), 0);
      exp = UINT64_C(0xff0000fb81800180);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_326() {

{
   {
      int16x4_t arg1;
      int16x4_t arg2;
      int16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"saturating_sub\", fnname = \"vqsub_s16\", rettype = \"int16x4_t\", argtypes = \"[int16x4_t,int16x4_t]\", vals = [VectorVal [IntegerVal 0,IntegerVal 0,IntegerVal (-1),IntegerVal (-32768)],VectorVal [IntegerVal (-1),IntegerVal (-4735),IntegerVal 17665,IntegerVal 0]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s16(UINT64_C(0x8000ffff00000000));
      arg2 = vcreate_s16(UINT64_C(0x00004501ed81ffff));
      clear_neon_saturated();
      //  Expect: "result" = 8000bafe127f0001
      result = vqsub_s16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s16(result), 0);
      exp = UINT64_C(0x8000bafe127f0001);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_327() {

{
   {
      int32x2_t arg1;
      int32x2_t arg2;
      int32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"saturating_sub\", fnname = \"vqsub_s32\", rettype = \"int32x2_t\", argtypes = \"[int32x2_t,int32x2_t]\", vals = [VectorVal [IntegerVal 1513127935,IntegerVal (-1)],VectorVal [IntegerVal 1081,IntegerVal 14545]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s32(UINT64_C(0xffffffff5a307fff));
      arg2 = vcreate_s32(UINT64_C(0x000038d100000439));
      clear_neon_saturated();
      //  Expect: "result" = ffffc72e5a307bc6
      result = vqsub_s32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s32(result), 0);
      exp = UINT64_C(0xffffc72e5a307bc6);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_328() {

{
   {
      int64x1_t arg1;
      int64x1_t arg2;
      int64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"saturating_sub\", fnname = \"vqsub_s64\", rettype = \"int64x1_t\", argtypes = \"[int64x1_t,int64x1_t]\", vals = [VectorVal [IntegerVal (-281472829227008)],VectorVal [IntegerVal 253431385718784]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s64(UINT64_C(0xffff000080000000));
      arg2 = vcreate_s64(UINT64_C(0x0000e67e97b88000));
      clear_neon_saturated();
      //  Expect: "result" = fffe1981e8478000
      result = vqsub_s64(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s64(result), 0);
      exp = UINT64_C(0xfffe1981e8478000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_329() {

{
   {
      uint8x8_t arg1;
      uint8x8_t arg2;
      uint8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"saturating_sub\", fnname = \"vqsub_u8\", rettype = \"uint8x8_t\", argtypes = \"[uint8x8_t,uint8x8_t]\", vals = [VectorVal [IntegerVal 19,IntegerVal 255,IntegerVal 128,IntegerVal 127,IntegerVal 128,IntegerVal 128,IntegerVal 127,IntegerVal 128],VectorVal [IntegerVal 127,IntegerVal 255,IntegerVal 0,IntegerVal 127,IntegerVal 0,IntegerVal 127,IntegerVal 127,IntegerVal 127]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u8(UINT64_C(0x807f80807f80ff13));
      arg2 = vcreate_u8(UINT64_C(0x7f7f7f007f00ff7f));
      clear_neon_saturated();
      //  Expect: "result" = 0100018000800000
      result = vqsub_u8(arg1, arg2);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u8(result), 0);
      exp = UINT64_C(0x0100018000800000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_330() {

{
   {
      uint16x4_t arg1;
      uint16x4_t arg2;
      uint16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"saturating_sub\", fnname = \"vqsub_u16\", rettype = \"uint16x4_t\", argtypes = \"[uint16x4_t,uint16x4_t]\", vals = [VectorVal [IntegerVal 61756,IntegerVal 65535,IntegerVal 32768,IntegerVal 32768],VectorVal [IntegerVal 0,IntegerVal 0,IntegerVal 65535,IntegerVal 43360]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u16(UINT64_C(0x80008000fffff13c));
      arg2 = vcreate_u16(UINT64_C(0xa960ffff00000000));
      clear_neon_saturated();
      //  Expect: "result" = 00000000fffff13c
      result = vqsub_u16(arg1, arg2);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u16(result), 0);
      exp = UINT64_C(0x00000000fffff13c);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_331() {

{
   {
      uint32x2_t arg1;
      uint32x2_t arg2;
      uint32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"saturating_sub\", fnname = \"vqsub_u32\", rettype = \"uint32x2_t\", argtypes = \"[uint32x2_t,uint32x2_t]\", vals = [VectorVal [IntegerVal 2147450880,IntegerVal 2147450879],VectorVal [IntegerVal 32768,IntegerVal 19517]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u32(UINT64_C(0x7fff7fff7fff8000));
      arg2 = vcreate_u32(UINT64_C(0x00004c3d00008000));
      clear_neon_saturated();
      //  Expect: "result" = 7fff33c27fff0000
      result = vqsub_u32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u32(result), 0);
      exp = UINT64_C(0x7fff33c27fff0000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_332() {

{
   {
      uint64x1_t arg1;
      uint64x1_t arg2;
      uint64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"saturating_sub\", fnname = \"vqsub_u64\", rettype = \"uint64x1_t\", argtypes = \"[uint64x1_t,uint64x1_t]\", vals = [VectorVal [IntegerVal 2073001983],VectorVal [IntegerVal 18446691675108474880]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u64(UINT64_C(0x000000007b8f7fff));
      arg2 = vcreate_u64(UINT64_C(0xffffd057ffff0000));
      clear_neon_saturated();
      //  Expect: "result" = 0000000000000000
      result = vqsub_u64(arg1, arg2);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      got = vget_lane_u64(result, 0);
      exp = 0;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_333() {

{
   {
      int8x16_t arg1;
      int8x16_t arg2;
      int8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"saturating_sub\", fnname = \"vqsubq_s8\", rettype = \"int8x16_t\", argtypes = \"[int8x16_t,int8x16_t]\", vals = [VectorVal [IntegerVal (-1),IntegerVal (-1),IntegerVal (-125),IntegerVal (-1),IntegerVal 19,IntegerVal 116,IntegerVal 121,IntegerVal 96,IntegerVal (-1),IntegerVal 127,IntegerVal 0,IntegerVal (-47),IntegerVal 0,IntegerVal (-1),IntegerVal 0,IntegerVal (-1)],VectorVal [IntegerVal 127,IntegerVal 84,IntegerVal 127,IntegerVal 127,IntegerVal 0,IntegerVal 127,IntegerVal (-128),IntegerVal 0,IntegerVal 0,IntegerVal 0,IntegerVal 127,IntegerVal 0,IntegerVal 127,IntegerVal (-128),IntegerVal 127,IntegerVal (-51)]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s8(vcreate_s8(UINT64_C(0x60797413ff83ffff)),
                         vcreate_s8(UINT64_C(0xff00ff00d1007fff)));
      arg2 = vcombine_s8(vcreate_s8(UINT64_C(0x00807f007f7f547f)),
                         vcreate_s8(UINT64_C(0xcd7f807f007f0000)));
      clear_neon_saturated();
      //  Expect: "result" = 32817f81d1817fff607ff5138080ab80
      result = vqsubq_s8(arg1, arg2);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result), 0);
         exp = UINT64_C(0x607ff5138080ab80);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result), 1);
         exp = UINT64_C(0x32817f81d1817fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_334() {

{
   {
      int16x8_t arg1;
      int16x8_t arg2;
      int16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"saturating_sub\", fnname = \"vqsubq_s16\", rettype = \"int16x8_t\", argtypes = \"[int16x8_t,int16x8_t]\", vals = [VectorVal [IntegerVal (-1),IntegerVal (-32768),IntegerVal 0,IntegerVal (-1),IntegerVal (-32768),IntegerVal 32767,IntegerVal 0,IntegerVal 14146],VectorVal [IntegerVal 25741,IntegerVal (-32768),IntegerVal (-1),IntegerVal 21103,IntegerVal (-1),IntegerVal 32767,IntegerVal 0,IntegerVal 0]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s16(vcreate_s16(UINT64_C(0xffff00008000ffff)),
                          vcreate_s16(UINT64_C(0x374200007fff8000)));
      arg2 = vcombine_s16(vcreate_s16(UINT64_C(0x526fffff8000648d)),
                          vcreate_s16(UINT64_C(0x000000007fffffff)));
      clear_neon_saturated();
      //  Expect: "result" = 3742000000008001ad90000100009b72
      result = vqsubq_s16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 0);
         exp = UINT64_C(0xad90000100009b72);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 1);
         exp = UINT64_C(0x3742000000008001);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_335() {

{
   {
      int32x4_t arg1;
      int32x4_t arg2;
      int32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"saturating_sub\", fnname = \"vqsubq_s32\", rettype = \"int32x4_t\", argtypes = \"[int32x4_t,int32x4_t]\", vals = [VectorVal [IntegerVal (-1800273920),IntegerVal 65535,IntegerVal (-32768),IntegerVal (-727810049)],VectorVal [IntegerVal (-1670971392),IntegerVal (-1),IntegerVal (-32768),IntegerVal 26116]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s32(vcreate_s32(UINT64_C(0x0000ffff94b20000)),
                          vcreate_s32(UINT64_C(0xd49e7fffffff8000)));
      arg2 = vcombine_s32(vcreate_s32(UINT64_C(0xffffffff9c670000)),
                          vcreate_s32(UINT64_C(0x00006604ffff8000)));
      clear_neon_saturated();
      //  Expect: "result" = d49e19fb0000000000010000f84b0000
      result = vqsubq_s32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 0);
         exp = UINT64_C(0x00010000f84b0000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 1);
         exp = UINT64_C(0xd49e19fb00000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_336() {

{
   {
      int64x2_t arg1;
      int64x2_t arg2;
      int64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"saturating_sub\", fnname = \"vqsubq_s64\", rettype = \"int64x2_t\", argtypes = \"[int64x2_t,int64x2_t]\", vals = [VectorVal [IntegerVal 9223090565880741888,IntegerVal (-9223090564121670708)],VectorVal [IntegerVal 140739635838976,IntegerVal (-9223231297218966286)]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s64(vcreate_s64(UINT64_C(0x7fff0000ee940000)),
                          vcreate_s64(UINT64_C(0x8000ffff7a454bcc)));
      arg2 = vcombine_s64(vcreate_s64(UINT64_C(0x0000800080000000)),
                          vcreate_s64(UINT64_C(0x800080007fff8cf2)));
      clear_neon_saturated();
      //  Expect: "result" = 00007ffefa45beda7ffe80006e940000
      result = vqsubq_s64(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 0);
         exp = UINT64_C(0x7ffe80006e940000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 1);
         exp = UINT64_C(0x00007ffefa45beda);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_337() {

{
   {
      uint8x16_t arg1;
      uint8x16_t arg2;
      uint8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"saturating_sub\", fnname = \"vqsubq_u8\", rettype = \"uint8x16_t\", argtypes = \"[uint8x16_t,uint8x16_t]\", vals = [VectorVal [IntegerVal 127,IntegerVal 0,IntegerVal 127,IntegerVal 0,IntegerVal 65,IntegerVal 0,IntegerVal 128,IntegerVal 0,IntegerVal 0,IntegerVal 128,IntegerVal 127,IntegerVal 127,IntegerVal 114,IntegerVal 127,IntegerVal 0,IntegerVal 14],VectorVal [IntegerVal 255,IntegerVal 0,IntegerVal 128,IntegerVal 127,IntegerVal 0,IntegerVal 255,IntegerVal 128,IntegerVal 90,IntegerVal 128,IntegerVal 255,IntegerVal 127,IntegerVal 128,IntegerVal 128,IntegerVal 172,IntegerVal 255,IntegerVal 176]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u8(vcreate_u8(UINT64_C(0x00800041007f007f)),
                         vcreate_u8(UINT64_C(0x0e007f727f7f8000)));
      arg2 = vcombine_u8(vcreate_u8(UINT64_C(0x5a80ff007f8000ff)),
                         vcreate_u8(UINT64_C(0xb0ffac80807fff80)));
      clear_neon_saturated();
      //  Expect: "result" = 00000000000000000000004100000000
      result = vqsubq_u8(arg1, arg2);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 0);
         exp = UINT64_C(0x0000004100000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 1);
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_338() {

{
   {
      uint16x8_t arg1;
      uint16x8_t arg2;
      uint16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"saturating_sub\", fnname = \"vqsubq_u16\", rettype = \"uint16x8_t\", argtypes = \"[uint16x8_t,uint16x8_t]\", vals = [VectorVal [IntegerVal 0,IntegerVal 65535,IntegerVal 32768,IntegerVal 65535,IntegerVal 32767,IntegerVal 65535,IntegerVal 65535,IntegerVal 0],VectorVal [IntegerVal 29915,IntegerVal 0,IntegerVal 32767,IntegerVal 0,IntegerVal 0,IntegerVal 62072,IntegerVal 65535,IntegerVal 0]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u16(vcreate_u16(UINT64_C(0xffff8000ffff0000)),
                          vcreate_u16(UINT64_C(0x0000ffffffff7fff)));
      arg2 = vcombine_u16(vcreate_u16(UINT64_C(0x00007fff000074db)),
                          vcreate_u16(UINT64_C(0x0000fffff2780000)));
      clear_neon_saturated();
      //  Expect: "result" = 000000000d877fffffff0001ffff0000
      result = vqsubq_u16(arg1, arg2);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 0);
         exp = UINT64_C(0xffff0001ffff0000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 1);
         exp = UINT64_C(0x000000000d877fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_339() {

{
   {
      uint32x4_t arg1;
      uint32x4_t arg2;
      uint32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"saturating_sub\", fnname = \"vqsubq_u32\", rettype = \"uint32x4_t\", argtypes = \"[uint32x4_t,uint32x4_t]\", vals = [VectorVal [IntegerVal 2147450880,IntegerVal 2147483648,IntegerVal 4294964763,IntegerVal 22159],VectorVal [IntegerVal 2147498796,IntegerVal 4294909770,IntegerVal 32767,IntegerVal 1556742143]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u32(vcreate_u32(UINT64_C(0x800000007fff8000)),
                          vcreate_u32(UINT64_C(0x0000568ffffff61b)));
      arg2 = vcombine_u32(vcreate_u32(UINT64_C(0xffff1f4a80003b2c)),
                          vcreate_u32(UINT64_C(0x5cc9ffff00007fff)));
      clear_neon_saturated();
      //  Expect: "result" = 00000000ffff761c0000000000000000
      result = vqsubq_u32(arg1, arg2);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 0);
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 1);
         exp = UINT64_C(0x00000000ffff761c);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_340() {

{
   {
      uint64x2_t arg1;
      uint64x2_t arg2;
      uint64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"saturating_sub\", fnname = \"vqsubq_u64\", rettype = \"uint64x2_t\", argtypes = \"[uint64x2_t,uint64x2_t]\", vals = [VectorVal [IntegerVal 2147450879,IntegerVal 18446603338368745471],VectorVal [IntegerVal 4206362051964048524,IntegerVal 9223559074090614784]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u64(vcreate_u64(UINT64_C(0x000000007fff7fff)),
                          vcreate_u64(UINT64_C(0xffff80008000ffff)));
      arg2 = vcombine_u64(vcreate_u64(UINT64_C(0x3a6000000000148c)),
                          vcreate_u64(UINT64_C(0x8000aa1c00008000)));
      clear_neon_saturated();
      //  Expect: "result" = 7ffed5e480007fff0000000000000000
      result = vqsubq_u64(arg1, arg2);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 0);
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 1);
         exp = UINT64_C(0x7ffed5e480007fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_341() {

{
   {
      int8_t arg1;
      int8_t arg2;
      int8_t result;
      char* str1 = "ReproInfo2 {semantics = \"saturating_sub\", fnname = \"vqsubb_s8\", rettype = \"int8_t\", argtypes = \"[int8_t,int8_t]\", vals = [IntegerVal (-1),IntegerVal 0], start_saturated = False}";
      int reported = 0;
      int8_t got;
      int8_t exp;
      arg1 = -1;
      arg2 = 0;
      clear_neon_saturated();
      //  Expect: "result" = ff
      result = vqsubb_s8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = -1;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_342() {

{
   {
      int16_t arg1;
      int16_t arg2;
      int16_t result;
      char* str1 = "ReproInfo2 {semantics = \"saturating_sub\", fnname = \"vqsubh_s16\", rettype = \"int16_t\", argtypes = \"[int16_t,int16_t]\", vals = [IntegerVal (-3799),IntegerVal (-1)], start_saturated = False}";
      int reported = 0;
      int16_t got;
      int16_t exp;
      arg1 = -3799;
      arg2 = -1;
      clear_neon_saturated();
      //  Expect: "result" = f12a
      result = vqsubh_s16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = -3798;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIi16 " Got: %" PRIi16 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_343() {

{
   {
      int32_t arg1;
      int32_t arg2;
      int32_t result;
      char* str1 = "ReproInfo2 {semantics = \"saturating_sub\", fnname = \"vqsubs_s32\", rettype = \"int32_t\", argtypes = \"[int32_t,int32_t]\", vals = [IntegerVal (-1),IntegerVal (-32768)], start_saturated = False}";
      int reported = 0;
      int32_t got;
      int32_t exp;
      arg1 = -1;
      arg2 = -32768;
      clear_neon_saturated();
      //  Expect: "result" = 00007fff
      result = vqsubs_s32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = 32767;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIi32 " Got: %" PRIi32 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_344() {

{
   {
      int64_t arg1;
      int64_t arg2;
      int64_t result;
      char* str1 = "ReproInfo2 {semantics = \"saturating_sub\", fnname = \"vqsubd_s64\", rettype = \"int64_t\", argtypes = \"[int64_t,int64_t]\", vals = [IntegerVal (-9223341757335306240),IntegerVal (-140739635838976)], start_saturated = False}";
      int reported = 0;
      int64_t got;
      int64_t exp;
      arg1 = INT64_C(-9223341757335306240);
      arg2 = INT64_C(-140739635838976);
      clear_neon_saturated();
      //  Expect: "result" = 80009b8a80008000
      result = vqsubd_s64(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = INT64_C(-9223201017699467264);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIi64 " Got: %" PRIi64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_345() {

{
   {
      uint8_t arg1;
      uint8_t arg2;
      uint8_t result;
      char* str1 = "ReproInfo2 {semantics = \"saturating_sub\", fnname = \"vqsubb_u8\", rettype = \"uint8_t\", argtypes = \"[uint8_t,uint8_t]\", vals = [IntegerVal 0,IntegerVal 0], start_saturated = False}";
      int reported = 0;
      uint8_t got;
      uint8_t exp;
      arg1 = 0;
      arg2 = 0;
      clear_neon_saturated();
      //  Expect: "result" = 00
      result = vqsubb_u8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = 0;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_346() {

{
   {
      uint16_t arg1;
      uint16_t arg2;
      uint16_t result;
      char* str1 = "ReproInfo2 {semantics = \"saturating_sub\", fnname = \"vqsubh_u16\", rettype = \"uint16_t\", argtypes = \"[uint16_t,uint16_t]\", vals = [IntegerVal 65535,IntegerVal 32767], start_saturated = False}";
      int reported = 0;
      uint16_t got;
      uint16_t exp;
      arg1 = 65535U;
      arg2 = 32767U;
      clear_neon_saturated();
      //  Expect: "result" = 8000
      result = vqsubh_u16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = 32768U;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_347() {

{
   {
      uint32_t arg1;
      uint32_t arg2;
      uint32_t result;
      char* str1 = "ReproInfo2 {semantics = \"saturating_sub\", fnname = \"vqsubs_u32\", rettype = \"uint32_t\", argtypes = \"[uint32_t,uint32_t]\", vals = [IntegerVal 2147450880,IntegerVal 2147450880], start_saturated = False}";
      int reported = 0;
      uint32_t got;
      uint32_t exp;
      arg1 = 2147450880U;
      arg2 = 2147450880U;
      clear_neon_saturated();
      //  Expect: "result" = 00000000
      result = vqsubs_u32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = 0;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIu32 " Got: %" PRIu32 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_348() {

{
   {
      uint64_t arg1;
      uint64_t arg2;
      uint64_t result;
      char* str1 = "ReproInfo2 {semantics = \"saturating_sub\", fnname = \"vqsubd_u64\", rettype = \"uint64_t\", argtypes = \"[uint64_t,uint64_t]\", vals = [IntegerVal 9223433268055971537,IntegerVal 9223512770114781183], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = UINT64_C(0x800037b07fff16d1);
      arg2 = UINT64_C(0x80007fff03f87fff);
      clear_neon_saturated();
      //  Expect: "result" = 0000000000000000
      result = vqsubd_u64(arg1, arg2);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      got = result;
      exp = 0;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_349() {

{
   {
      int8x8_t arg1;
      int8x8_t arg2;
      int8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"halving_sub\", fnname = \"vhsub_s8\", rettype = \"int8x8_t\", argtypes = \"[int8x8_t,int8x8_t]\", vals = [VectorVal [IntegerVal 0,IntegerVal 105,IntegerVal (-94),IntegerVal (-128),IntegerVal (-45),IntegerVal 0,IntegerVal 127,IntegerVal (-12)],VectorVal [IntegerVal 0,IntegerVal 0,IntegerVal (-1),IntegerVal (-1),IntegerVal (-128),IntegerVal 127,IntegerVal 127,IntegerVal (-128)]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s8(UINT64_C(0xf47f00d380a26900));
      arg2 = vcreate_s8(UINT64_C(0x807f7f80ffff0000));
      clear_neon_saturated();
      //  Expect: "result" = 3a00c029c0d13400
      result = vhsub_s8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s8(result), 0);
      exp = UINT64_C(0x3a00c029c0d13400);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_350() {

{
   {
      int16x4_t arg1;
      int16x4_t arg2;
      int16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"halving_sub\", fnname = \"vhsub_s16\", rettype = \"int16x4_t\", argtypes = \"[int16x4_t,int16x4_t]\", vals = [VectorVal [IntegerVal (-32768),IntegerVal (-1),IntegerVal 32767,IntegerVal 32767],VectorVal [IntegerVal (-32768),IntegerVal (-32768),IntegerVal (-32768),IntegerVal 13667]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s16(UINT64_C(0x7fff7fffffff8000));
      arg2 = vcreate_s16(UINT64_C(0x3563800080008000));
      clear_neon_saturated();
      //  Expect: "result" = 254e7fff3fff0000
      result = vhsub_s16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s16(result), 0);
      exp = UINT64_C(0x254e7fff3fff0000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_351() {

{
   {
      int32x2_t arg1;
      int32x2_t arg2;
      int32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"halving_sub\", fnname = \"vhsub_s32\", rettype = \"int32x2_t\", argtypes = \"[int32x2_t,int32x2_t]\", vals = [VectorVal [IntegerVal (-32769),IntegerVal (-1914601472)],VectorVal [IntegerVal 1878196224,IntegerVal 2084024778]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s32(UINT64_C(0x8de18000ffff7fff));
      arg2 = vcreate_s32(UINT64_C(0x7c37b1ca6ff30000));
      clear_neon_saturated();
      //  Expect: "result" = 88d4e71bc8063fff
      result = vhsub_s32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s32(result), 0);
      exp = UINT64_C(0x88d4e71bc8063fff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_352() {

{
   {
      uint8x8_t arg1;
      uint8x8_t arg2;
      uint8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"halving_sub\", fnname = \"vhsub_u8\", rettype = \"uint8x8_t\", argtypes = \"[uint8x8_t,uint8x8_t]\", vals = [VectorVal [IntegerVal 127,IntegerVal 0,IntegerVal 224,IntegerVal 128,IntegerVal 127,IntegerVal 255,IntegerVal 255,IntegerVal 127],VectorVal [IntegerVal 255,IntegerVal 0,IntegerVal 128,IntegerVal 177,IntegerVal 253,IntegerVal 255,IntegerVal 16,IntegerVal 0]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u8(UINT64_C(0x7fffff7f80e0007f));
      arg2 = vcreate_u8(UINT64_C(0x0010fffdb18000ff));
      clear_neon_saturated();
      //  Expect: "result" = 3f7700c1e73000c0
      result = vhsub_u8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u8(result), 0);
      exp = UINT64_C(0x3f7700c1e73000c0);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_353() {

{
   {
      uint16x4_t arg1;
      uint16x4_t arg2;
      uint16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"halving_sub\", fnname = \"vhsub_u16\", rettype = \"uint16x4_t\", argtypes = \"[uint16x4_t,uint16x4_t]\", vals = [VectorVal [IntegerVal 32768,IntegerVal 32768,IntegerVal 0,IntegerVal 32975],VectorVal [IntegerVal 0,IntegerVal 32767,IntegerVal 32768,IntegerVal 0]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u16(UINT64_C(0x80cf000080008000));
      arg2 = vcreate_u16(UINT64_C(0x000080007fff0000));
      clear_neon_saturated();
      //  Expect: "result" = 4067c00000004000
      result = vhsub_u16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u16(result), 0);
      exp = UINT64_C(0x4067c00000004000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_354() {

{
   {
      uint32x2_t arg1;
      uint32x2_t arg2;
      uint32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"halving_sub\", fnname = \"vhsub_u32\", rettype = \"uint32x2_t\", argtypes = \"[uint32x2_t,uint32x2_t]\", vals = [VectorVal [IntegerVal 2147516415,IntegerVal 0],VectorVal [IntegerVal 2147517250,IntegerVal 2147516415]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u32(UINT64_C(0x0000000080007fff));
      arg2 = vcreate_u32(UINT64_C(0x80007fff80008342));
      clear_neon_saturated();
      //  Expect: "result" = bfffc000fffffe5e
      result = vhsub_u32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u32(result), 0);
      exp = UINT64_C(0xbfffc000fffffe5e);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_355() {

{
   {
      int8x16_t arg1;
      int8x16_t arg2;
      int8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"halving_sub\", fnname = \"vhsubq_s8\", rettype = \"int8x16_t\", argtypes = \"[int8x16_t,int8x16_t]\", vals = [VectorVal [IntegerVal 127,IntegerVal (-128),IntegerVal (-128),IntegerVal (-128),IntegerVal 0,IntegerVal (-1),IntegerVal (-71),IntegerVal (-128),IntegerVal 127,IntegerVal (-1),IntegerVal 0,IntegerVal (-128),IntegerVal (-128),IntegerVal (-1),IntegerVal (-128),IntegerVal (-128)],VectorVal [IntegerVal (-128),IntegerVal (-104),IntegerVal 66,IntegerVal (-128),IntegerVal 127,IntegerVal (-1),IntegerVal 127,IntegerVal 127,IntegerVal (-1),IntegerVal (-15),IntegerVal (-128),IntegerVal 0,IntegerVal (-128),IntegerVal (-33),IntegerVal (-1),IntegerVal 30]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s8(vcreate_s8(UINT64_C(0x80b9ff008080807f)),
                         vcreate_s8(UINT64_C(0x8080ff808000ff7f)));
      arg2 = vcombine_s8(vcreate_s8(UINT64_C(0x7f7fff7f80429880)),
                         vcreate_s8(UINT64_C(0x1effdf800080f1ff)));
      clear_neon_saturated();
      //  Expect: "result" = b1c01000c0400740809d00c0009ff47f
      result = vhsubq_s8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result), 0);
         exp = UINT64_C(0x809d00c0009ff47f);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result), 1);
         exp = UINT64_C(0xb1c01000c0400740);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_356() {

{
   {
      int16x8_t arg1;
      int16x8_t arg2;
      int16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"halving_sub\", fnname = \"vhsubq_s16\", rettype = \"int16x8_t\", argtypes = \"[int16x8_t,int16x8_t]\", vals = [VectorVal [IntegerVal (-1),IntegerVal (-10037),IntegerVal (-1),IntegerVal 32767,IntegerVal (-32768),IntegerVal 32767,IntegerVal (-32768),IntegerVal 30989],VectorVal [IntegerVal (-1),IntegerVal 32767,IntegerVal (-2198),IntegerVal 0,IntegerVal (-32768),IntegerVal 32767,IntegerVal 0,IntegerVal (-1)]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s16(vcreate_s16(UINT64_C(0x7fffffffd8cbffff)),
                          vcreate_s16(UINT64_C(0x790d80007fff8000)));
      arg2 = vcombine_s16(vcreate_s16(UINT64_C(0x0000f76a7fffffff)),
                          vcreate_s16(UINT64_C(0xffff00007fff8000)));
      clear_neon_saturated();
      //  Expect: "result" = 3c87c000000000003fff044aac660000
      result = vhsubq_s16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 0);
         exp = UINT64_C(0x3fff044aac660000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 1);
         exp = UINT64_C(0x3c87c00000000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_357() {

{
   {
      int32x4_t arg1;
      int32x4_t arg2;
      int32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"halving_sub\", fnname = \"vhsubq_s32\", rettype = \"int32x4_t\", argtypes = \"[int32x4_t,int32x4_t]\", vals = [VectorVal [IntegerVal 6939,IntegerVal (-35425),IntegerVal (-65536),IntegerVal 2147450880],VectorVal [IntegerVal (-2147450880),IntegerVal 65535,IntegerVal 65535,IntegerVal (-2147483648)]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s32(vcreate_s32(UINT64_C(0xffff759f00001b1b)),
                          vcreate_s32(UINT64_C(0x7fff8000ffff0000)));
      arg2 = vcombine_s32(vcreate_s32(UINT64_C(0x0000ffff80008000)),
                          vcreate_s32(UINT64_C(0x800000000000ffff)));
      clear_neon_saturated();
      //  Expect: "result" = 7fffc000ffff0000ffff3ad03fffcd8d
      result = vhsubq_s32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 0);
         exp = UINT64_C(0xffff3ad03fffcd8d);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 1);
         exp = UINT64_C(0x7fffc000ffff0000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_358() {

{
   {
      uint8x16_t arg1;
      uint8x16_t arg2;
      uint8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"halving_sub\", fnname = \"vhsubq_u8\", rettype = \"uint8x16_t\", argtypes = \"[uint8x16_t,uint8x16_t]\", vals = [VectorVal [IntegerVal 222,IntegerVal 128,IntegerVal 127,IntegerVal 128,IntegerVal 253,IntegerVal 106,IntegerVal 127,IntegerVal 128,IntegerVal 0,IntegerVal 255,IntegerVal 127,IntegerVal 128,IntegerVal 255,IntegerVal 37,IntegerVal 0,IntegerVal 0],VectorVal [IntegerVal 127,IntegerVal 127,IntegerVal 180,IntegerVal 112,IntegerVal 255,IntegerVal 128,IntegerVal 0,IntegerVal 99,IntegerVal 128,IntegerVal 253,IntegerVal 127,IntegerVal 128,IntegerVal 128,IntegerVal 255,IntegerVal 0,IntegerVal 128]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u8(vcreate_u8(UINT64_C(0x807f6afd807f80de)),
                         vcreate_u8(UINT64_C(0x000025ff807fff00)));
      arg2 = vcombine_u8(vcreate_u8(UINT64_C(0x630080ff70b47f7f)),
                         vcreate_u8(UINT64_C(0x8000ff80807ffd80)));
      clear_neon_saturated();
      //  Expect: "result" = c000933f000001c00e3ff5ff08e5002f
      result = vhsubq_u8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 0);
         exp = UINT64_C(0x0e3ff5ff08e5002f);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 1);
         exp = UINT64_C(0xc000933f000001c0);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_359() {

{
   {
      uint16x8_t arg1;
      uint16x8_t arg2;
      uint16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"halving_sub\", fnname = \"vhsubq_u16\", rettype = \"uint16x8_t\", argtypes = \"[uint16x8_t,uint16x8_t]\", vals = [VectorVal [IntegerVal 0,IntegerVal 65535,IntegerVal 65535,IntegerVal 65535,IntegerVal 65535,IntegerVal 0,IntegerVal 32768,IntegerVal 65535],VectorVal [IntegerVal 32768,IntegerVal 0,IntegerVal 65535,IntegerVal 0,IntegerVal 32768,IntegerVal 2925,IntegerVal 32767,IntegerVal 0]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u16(vcreate_u16(UINT64_C(0xffffffffffff0000)),
                          vcreate_u16(UINT64_C(0xffff80000000ffff)));
      arg2 = vcombine_u16(vcreate_u16(UINT64_C(0x0000ffff00008000)),
                          vcreate_u16(UINT64_C(0x00007fff0b6d8000)));
      clear_neon_saturated();
      //  Expect: "result" = 7fff0000fa493fff7fff00007fffc000
      result = vhsubq_u16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 0);
         exp = UINT64_C(0x7fff00007fffc000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 1);
         exp = UINT64_C(0x7fff0000fa493fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_360() {

{
   {
      uint32x4_t arg1;
      uint32x4_t arg2;
      uint32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"halving_sub\", fnname = \"vhsubq_u32\", rettype = \"uint32x4_t\", argtypes = \"[uint32x4_t,uint32x4_t]\", vals = [VectorVal [IntegerVal 2147483648,IntegerVal 65535,IntegerVal 2147428255,IntegerVal 2147549183],VectorVal [IntegerVal 2147525836,IntegerVal 2824667136,IntegerVal 2147418112,IntegerVal 728104959]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u32(vcreate_u32(UINT64_C(0x0000ffff80000000)),
                          vcreate_u32(UINT64_C(0x8000ffff7fff279f)));
      arg2 = vcombine_u32(vcreate_u32(UINT64_C(0xa85d00008000a4cc)),
                          vcreate_u32(UINT64_C(0x2b65ffff7fff0000)));
      clear_neon_saturated();
      //  Expect: "result" = 2a4d8000000013cfabd1ffffffffad9a
      result = vhsubq_u32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 0);
         exp = UINT64_C(0xabd1ffffffffad9a);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 1);
         exp = UINT64_C(0x2a4d8000000013cf);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_361() {

{
   {
      int16x8_t arg1;
      int16x8_t arg2;
      int8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"highhalf_sub\", fnname = \"vsubhn_s16\", rettype = \"int8x8_t\", argtypes = \"[int16x8_t,int16x8_t]\", vals = [VectorVal [IntegerVal 32767,IntegerVal (-1),IntegerVal 32767,IntegerVal 32767,IntegerVal (-32768),IntegerVal 0,IntegerVal (-32768),IntegerVal 0],VectorVal [IntegerVal 0,IntegerVal 32767,IntegerVal (-1),IntegerVal (-32768),IntegerVal (-26367),IntegerVal (-32768),IntegerVal (-1),IntegerVal (-32768)]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcombine_s16(vcreate_s16(UINT64_C(0x7fff7fffffff7fff)),
                          vcreate_s16(UINT64_C(0x0000800000008000)));
      arg2 = vcombine_s16(vcreate_s16(UINT64_C(0x8000ffff7fff0000)),
                          vcreate_s16(UINT64_C(0x8000ffff80009901)));
      clear_neon_saturated();
      //  Expect: "result" = 808080e6ff80807f
      result = vsubhn_s16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s8(result), 0);
      exp = UINT64_C(0x808080e6ff80807f);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_362() {

{
   {
      int32x4_t arg1;
      int32x4_t arg2;
      int16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"highhalf_sub\", fnname = \"vsubhn_s32\", rettype = \"int16x4_t\", argtypes = \"[int32x4_t,int32x4_t]\", vals = [VectorVal [IntegerVal (-2147483648),IntegerVal (-1544814593),IntegerVal 61243391,IntegerVal (-65536)],VectorVal [IntegerVal 29416,IntegerVal 1273167872,IntegerVal 65535,IntegerVal 1129644032]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcombine_s32(vcreate_s32(UINT64_C(0xa3ebffff80000000)),
                          vcreate_s32(UINT64_C(0xffff000003a67fff)));
      arg2 = vcombine_s32(vcreate_s32(UINT64_C(0x4be30000000072e8)),
                          vcreate_s32(UINT64_C(0x435500000000ffff)));
      clear_neon_saturated();
      //  Expect: "result" = bcaa03a558087fff
      result = vsubhn_s32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s16(result), 0);
      exp = UINT64_C(0xbcaa03a558087fff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_363() {

{
   {
      int64x2_t arg1;
      int64x2_t arg2;
      int32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"highhalf_sub\", fnname = \"vsubhn_s64\", rettype = \"int32x2_t\", argtypes = \"[int64x2_t,int64x2_t]\", vals = [VectorVal [IntegerVal 281470681783027,IntegerVal 2824460651655593983],VectorVal [IntegerVal 9223231300677337088,IntegerVal 9223372032559841279]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcombine_s64(vcreate_s64(UINT64_C(0x0000ffff00009af3)),
                          vcreate_s64(UINT64_C(0x27327fff7fffffff)));
      arg2 = vcombine_s64(vcreate_s64(UINT64_C(0x7fff80004e230000)),
                          vcreate_s64(UINT64_C(0x7fffffff00007fff)));
      clear_neon_saturated();
      //  Expect: "result" = a732800080017ffe
      result = vsubhn_s64(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s32(result), 0);
      exp = UINT64_C(0xa732800080017ffe);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_364() {

{
   {
      uint16x8_t arg1;
      uint16x8_t arg2;
      uint8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"highhalf_sub\", fnname = \"vsubhn_u16\", rettype = \"uint8x8_t\", argtypes = \"[uint16x8_t,uint16x8_t]\", vals = [VectorVal [IntegerVal 65535,IntegerVal 0,IntegerVal 65535,IntegerVal 0,IntegerVal 65535,IntegerVal 0,IntegerVal 32767,IntegerVal 32767],VectorVal [IntegerVal 0,IntegerVal 65535,IntegerVal 14549,IntegerVal 65535,IntegerVal 32768,IntegerVal 32768,IntegerVal 65535,IntegerVal 0]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcombine_u16(vcreate_u16(UINT64_C(0x0000ffff0000ffff)),
                          vcreate_u16(UINT64_C(0x7fff7fff0000ffff)));
      arg2 = vcombine_u16(vcreate_u16(UINT64_C(0xffff38d5ffff0000)),
                          vcreate_u16(UINT64_C(0x0000ffff80008000)));
      clear_neon_saturated();
      //  Expect: "result" = 7f80807f00c700ff
      result = vsubhn_u16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u8(result), 0);
      exp = UINT64_C(0x7f80807f00c700ff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_365() {

{
   {
      uint32x4_t arg1;
      uint32x4_t arg2;
      uint16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"highhalf_sub\", fnname = \"vsubhn_u32\", rettype = \"uint16x4_t\", argtypes = \"[uint32x4_t,uint32x4_t]\", vals = [VectorVal [IntegerVal 32767,IntegerVal 2147507352,IntegerVal 4294934528,IntegerVal 54648],VectorVal [IntegerVal 4294967295,IntegerVal 2147473191,IntegerVal 47248,IntegerVal 32767]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcombine_u32(vcreate_u32(UINT64_C(0x80005c9800007fff)),
                          vcreate_u32(UINT64_C(0x0000d578ffff8000)));
      arg2 = vcombine_u32(vcreate_u32(UINT64_C(0x7fffd727ffffffff)),
                          vcreate_u32(UINT64_C(0x00007fff0000b890)));
      clear_neon_saturated();
      //  Expect: "result" = 0000fffe00000000
      result = vsubhn_u32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u16(result), 0);
      exp = UINT64_C(0x0000fffe00000000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_366() {

{
   {
      uint64x2_t arg1;
      uint64x2_t arg2;
      uint32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"highhalf_sub\", fnname = \"vsubhn_u64\", rettype = \"uint32x2_t\", argtypes = \"[uint64x2_t,uint64x2_t]\", vals = [VectorVal [IntegerVal 18446603340516150911,IntegerVal 18446603331926294527],VectorVal [IntegerVal 9223231297218936831,IntegerVal 7099361858301233593]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcombine_u64(vcreate_u64(UINT64_C(0xffff8000ffffce7f)),
                          vcreate_u64(UINT64_C(0xffff7fff0000ffff)));
      arg2 = vcombine_u64(vcreate_u64(UINT64_C(0x7fff7fff7fffffff)),
                          vcreate_u64(UINT64_C(0x6285ffff000089b9)));
      clear_neon_saturated();
      //  Expect: "result" = 9d79800080000001
      result = vsubhn_u64(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u32(result), 0);
      exp = UINT64_C(0x9d79800080000001);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_367() {

{
   {
      int8x8_t arg1;
      int16x8_t arg2;
      int16x8_t arg3;
      int8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"highhalf_sub\", fnname = \"vsubhn_high_s16\", rettype = \"int8x16_t\", argtypes = \"[int8x8_t,int16x8_t,int16x8_t]\", vals = [VectorVal [IntegerVal 0,IntegerVal 127,IntegerVal (-128),IntegerVal (-128),IntegerVal 127,IntegerVal 0,IntegerVal (-1),IntegerVal (-1)],VectorVal [IntegerVal 32767,IntegerVal (-32768),IntegerVal 32767,IntegerVal 0,IntegerVal 0,IntegerVal (-904),IntegerVal 32767,IntegerVal 0],VectorVal [IntegerVal 11399,IntegerVal 0,IntegerVal (-32768),IntegerVal (-20507),IntegerVal 32767,IntegerVal 0,IntegerVal 0,IntegerVal (-1)]], start_saturated = True}";
      int reported = 0;
      arg1 = vcreate_s8(UINT64_C(0xffff007f80807f00));
      arg2 = vcombine_s16(vcreate_s16(UINT64_C(0x00007fff80007fff)),
                          vcreate_s16(UINT64_C(0x00007ffffc780000)));
      arg3 = vcombine_s16(vcreate_s16(UINT64_C(0xafe5800000002c87)),
                          vcreate_s16(UINT64_C(0xffff000000007fff)));
      set_neon_saturated();
      //  Expect: "result" = 007ffc8050ff8053ffff007f80807f00
      result = vsubhn_high_s16(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result), 0);
         exp = UINT64_C(0xffff007f80807f00);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result), 1);
         exp = UINT64_C(0x007ffc8050ff8053);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_368() {

{
   {
      int16x4_t arg1;
      int32x4_t arg2;
      int32x4_t arg3;
      int16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"highhalf_sub\", fnname = \"vsubhn_high_s32\", rettype = \"int16x8_t\", argtypes = \"[int16x4_t,int32x4_t,int32x4_t]\", vals = [VectorVal [IntegerVal 0,IntegerVal (-1),IntegerVal (-28850),IntegerVal 32767],VectorVal [IntegerVal 32768,IntegerVal (-65536),IntegerVal (-2147483648),IntegerVal 2147418112],VectorVal [IntegerVal (-1),IntegerVal (-1894350849),IntegerVal 65535,IntegerVal (-2147450881)]], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_s16(UINT64_C(0x7fff8f4effff0000));
      arg2 = vcombine_s32(vcreate_s32(UINT64_C(0xffff000000008000)),
                          vcreate_s32(UINT64_C(0x7fff000080000000)));
      arg3 = vcombine_s32(vcreate_s32(UINT64_C(0x8f167fffffffffff)),
                          vcreate_s32(UINT64_C(0x80007fff0000ffff)));
      clear_neon_saturated();
      //  Expect: "result" = fffe7fff70e800007fff8f4effff0000
      result = vsubhn_high_s32(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 0);
         exp = UINT64_C(0x7fff8f4effff0000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 1);
         exp = UINT64_C(0xfffe7fff70e80000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_369() {

{
   {
      int32x2_t arg1;
      int64x2_t arg2;
      int64x2_t arg3;
      int32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"highhalf_sub\", fnname = \"vsubhn_high_s64\", rettype = \"int32x4_t\", argtypes = \"[int32x2_t,int64x2_t,int64x2_t]\", vals = [VectorVal [IntegerVal 32767,IntegerVal (-2147436867)],VectorVal [IntegerVal 9223231303661355008,IntegerVal 1041739157241561088],VectorVal [IntegerVal (-3674937293259997185),IntegerVal 9223231299366453247]], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_s32(UINT64_C(0x8000b6bd00007fff));
      arg2 = vcombine_s64(vcreate_s64(UINT64_C(0x7fff8000ffff8000)),
                          vcreate_s64(UINT64_C(0x0e75003e7fff8000)));
      arg3 = vcombine_s64(vcreate_s64(UINT64_C(0xcd0000009f66ffff)),
                          vcreate_s64(UINT64_C(0x7fff800000007fff)));
      clear_neon_saturated();
      //  Expect: "result" = 8e75803eb2ff80008000b6bd00007fff
      result = vsubhn_high_s64(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 0);
         exp = UINT64_C(0x8000b6bd00007fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 1);
         exp = UINT64_C(0x8e75803eb2ff8000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_370() {

{
   {
      uint8x8_t arg1;
      uint16x8_t arg2;
      uint16x8_t arg3;
      uint8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"highhalf_sub\", fnname = \"vsubhn_high_u16\", rettype = \"uint8x16_t\", argtypes = \"[uint8x8_t,uint16x8_t,uint16x8_t]\", vals = [VectorVal [IntegerVal 128,IntegerVal 128,IntegerVal 247,IntegerVal 255,IntegerVal 191,IntegerVal 255,IntegerVal 127,IntegerVal 127],VectorVal [IntegerVal 65535,IntegerVal 32767,IntegerVal 32768,IntegerVal 65535,IntegerVal 13333,IntegerVal 48276,IntegerVal 32767,IntegerVal 21025],VectorVal [IntegerVal 65535,IntegerVal 65535,IntegerVal 46858,IntegerVal 0,IntegerVal 65535,IntegerVal 32768,IntegerVal 32768,IntegerVal 44825]], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_u8(UINT64_C(0x7f7fffbffff78080));
      arg2 = vcombine_u16(vcreate_u16(UINT64_C(0xffff80007fffffff)),
                          vcreate_u16(UINT64_C(0x52217fffbc943415)));
      arg3 = vcombine_u16(vcreate_u16(UINT64_C(0x0000b70affffffff)),
                          vcreate_u16(UINT64_C(0xaf1980008000ffff)));
      clear_neon_saturated();
      //  Expect: "result" = a3ff3c34ffc880007f7fffbffff78080
      result = vsubhn_high_u16(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 0);
         exp = UINT64_C(0x7f7fffbffff78080);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 1);
         exp = UINT64_C(0xa3ff3c34ffc88000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_371() {

{
   {
      uint16x4_t arg1;
      uint32x4_t arg2;
      uint32x4_t arg3;
      uint16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"highhalf_sub\", fnname = \"vsubhn_high_u32\", rettype = \"uint16x8_t\", argtypes = \"[uint16x4_t,uint32x4_t,uint32x4_t]\", vals = [VectorVal [IntegerVal 32768,IntegerVal 23159,IntegerVal 65535,IntegerVal 32767],VectorVal [IntegerVal 2147443466,IntegerVal 421330943,IntegerVal 2147418112,IntegerVal 4294934527],VectorVal [IntegerVal 2147450879,IntegerVal 65535,IntegerVal 2147516416,IntegerVal 4294901760]], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_u16(UINT64_C(0x7fffffff5a778000));
      arg2 = vcombine_u32(vcreate_u32(UINT64_C(0x191cffff7fff630a)),
                          vcreate_u32(UINT64_C(0xffff7fff7fff0000)));
      arg3 = vcombine_u32(vcreate_u32(UINT64_C(0x0000ffff7fff7fff)),
                          vcreate_u32(UINT64_C(0xffff000080008000)));
      clear_neon_saturated();
      //  Expect: "result" = 0000fffe191cffff7fffffff5a778000
      result = vsubhn_high_u32(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 0);
         exp = UINT64_C(0x7fffffff5a778000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 1);
         exp = UINT64_C(0x0000fffe191cffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_372() {

{
   {
      uint32x2_t arg1;
      uint64x2_t arg2;
      uint64x2_t arg3;
      uint32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"highhalf_sub\", fnname = \"vsubhn_high_u64\", rettype = \"uint32x4_t\", argtypes = \"[uint32x2_t,uint64x2_t,uint64x2_t]\", vals = [VectorVal [IntegerVal 2147549183,IntegerVal 65535],VectorVal [IntegerVal 18446462602652909568,IntegerVal 9223372032559862725],VectorVal [IntegerVal 9223144049253253119,IntegerVal 281472829269646]], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_u32(UINT64_C(0x0000ffff8000ffff));
      arg2 = vcombine_u64(vcreate_u64(UINT64_C(0xffff0000e9a78000)),
                          vcreate_u64(UINT64_C(0x7fffffff0000d3c5)));
      arg3 = vcombine_u64(vcreate_u64(UINT64_C(0x7fff30a57fff7fff)),
                          vcreate_u64(UINT64_C(0x0000ffff8000a68e)));
      clear_neon_saturated();
      //  Expect: "result" = 7ffeffff7fffcf5b0000ffff8000ffff
      result = vsubhn_high_u64(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 0);
         exp = UINT64_C(0x0000ffff8000ffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 1);
         exp = UINT64_C(0x7ffeffff7fffcf5b);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_373() {

{
   {
      int16x8_t arg1;
      int16x8_t arg2;
      int8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"roundinghighhalf_sub\", fnname = \"vrsubhn_s16\", rettype = \"int8x8_t\", argtypes = \"[int16x8_t,int16x8_t]\", vals = [VectorVal [IntegerVal (-32768),IntegerVal 20630,IntegerVal 32767,IntegerVal (-24445),IntegerVal 0,IntegerVal (-32768),IntegerVal (-1),IntegerVal 0],VectorVal [IntegerVal (-1),IntegerVal 16076,IntegerVal 0,IntegerVal (-32768),IntegerVal 2017,IntegerVal 0,IntegerVal 32767,IntegerVal (-14741)]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcombine_s16(vcreate_s16(UINT64_C(0xa0837fff50968000)),
                          vcreate_s16(UINT64_C(0x0000ffff80000000)));
      arg2 = vcombine_s16(vcreate_s16(UINT64_C(0x800000003eccffff)),
                          vcreate_s16(UINT64_C(0xc66b7fff000007e1)));
      clear_neon_saturated();
      //  Expect: "result" = 3a8080f821801280
      result = vrsubhn_s16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s8(result), 0);
      exp = UINT64_C(0x3a8080f821801280);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_374() {

{
   {
      int32x4_t arg1;
      int32x4_t arg2;
      int16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"roundinghighhalf_sub\", fnname = \"vrsubhn_s32\", rettype = \"int16x4_t\", argtypes = \"[int32x4_t,int32x4_t]\", vals = [VectorVal [IntegerVal 0,IntegerVal (-65536),IntegerVal (-2147418113),IntegerVal 0],VectorVal [IntegerVal 2147450879,IntegerVal 65535,IntegerVal (-65536),IntegerVal (-32768)]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcombine_s32(vcreate_s32(UINT64_C(0xffff000000000000)),
                          vcreate_s32(UINT64_C(0x000000008000ffff)));
      arg2 = vcombine_s32(vcreate_s32(UINT64_C(0x0000ffff7fff7fff)),
                          vcreate_s32(UINT64_C(0xffff8000ffff0000)));
      clear_neon_saturated();
      //  Expect: "result" = 00018002fffe8001
      result = vrsubhn_s32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s16(result), 0);
      exp = UINT64_C(0x00018002fffe8001);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_375() {

{
   {
      int64x2_t arg1;
      int64x2_t arg2;
      int32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"roundinghighhalf_sub\", fnname = \"vrsubhn_s64\", rettype = \"int32x2_t\", argtypes = \"[int64x2_t,int64x2_t]\", vals = [VectorVal [IntegerVal 1798906576157802496,IntegerVal (-9223231297218904064)],VectorVal [IntegerVal (-1558949160659517440),IntegerVal (-9223229946451755009)]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcombine_s64(vcreate_s64(UINT64_C(0x18f7000000000000)),
                          vcreate_s64(UINT64_C(0x8000800080008000)));
      arg2 = vcombine_s64(vcreate_s64(UINT64_C(0xea5d7fff7fff0000)),
                          vcreate_s64(UINT64_C(0x8000813affff7fff)));
      clear_neon_saturated();
      //  Expect: "result" = fffffec62e998001
      result = vrsubhn_s64(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s32(result), 0);
      exp = UINT64_C(0xfffffec62e998001);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_376() {

{
   {
      uint16x8_t arg1;
      uint16x8_t arg2;
      uint8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"roundinghighhalf_sub\", fnname = \"vrsubhn_u16\", rettype = \"uint8x8_t\", argtypes = \"[uint16x8_t,uint16x8_t]\", vals = [VectorVal [IntegerVal 32767,IntegerVal 44818,IntegerVal 0,IntegerVal 0,IntegerVal 15791,IntegerVal 0,IntegerVal 32767,IntegerVal 20237],VectorVal [IntegerVal 0,IntegerVal 0,IntegerVal 13864,IntegerVal 32768,IntegerVal 32768,IntegerVal 65535,IntegerVal 0,IntegerVal 32767]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcombine_u16(vcreate_u16(UINT64_C(0x00000000af127fff)),
                          vcreate_u16(UINT64_C(0x4f0d7fff00003daf)));
      arg2 = vcombine_u16(vcreate_u16(UINT64_C(0x8000362800000000)),
                          vcreate_u16(UINT64_C(0x7fff0000ffff8000)));
      clear_neon_saturated();
      //  Expect: "result" = cf8000be80caaf80
      result = vrsubhn_u16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u8(result), 0);
      exp = UINT64_C(0xcf8000be80caaf80);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_377() {

{
   {
      uint32x4_t arg1;
      uint32x4_t arg2;
      uint16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"roundinghighhalf_sub\", fnname = \"vrsubhn_u32\", rettype = \"uint16x4_t\", argtypes = \"[uint32x4_t,uint32x4_t]\", vals = [VectorVal [IntegerVal 2734260223,IntegerVal 2147529491,IntegerVal 2147450880,IntegerVal 2147516416],VectorVal [IntegerVal 2147549183,IntegerVal 2147418112,IntegerVal 2147450880,IntegerVal 6799]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcombine_u32(vcreate_u32(UINT64_C(0x8000b313a2f97fff)),
                          vcreate_u32(UINT64_C(0x800080007fff8000)));
      arg2 = vcombine_u32(vcreate_u32(UINT64_C(0x7fff00008000ffff)),
                          vcreate_u32(UINT64_C(0x00001a8f7fff8000)));
      clear_neon_saturated();
      //  Expect: "result" = 80000000000222f9
      result = vrsubhn_u32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u16(result), 0);
      exp = UINT64_C(0x80000000000222f9);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_378() {

{
   {
      uint64x2_t arg1;
      uint64x2_t arg2;
      uint32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"roundinghighhalf_sub\", fnname = \"vrsubhn_u64\", rettype = \"uint32x2_t\", argtypes = \"[uint64x2_t,uint64x2_t]\", vals = [VectorVal [IntegerVal 7222366429566173183,IntegerVal 9223231297218969599],VectorVal [IntegerVal 9223231297219002367,IntegerVal 9223653511831420928]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcombine_u64(vcreate_u64(UINT64_C(0x643b00007fff7fff)),
                          vcreate_u64(UINT64_C(0x7fff7fff80007fff)));
      arg2 = vcombine_u64(vcreate_u64(UINT64_C(0x7fff7fff8000ffff)),
                          vcreate_u64(UINT64_C(0x8000ffffffff0000)));
      clear_neon_saturated();
      //  Expect: "result" = fffe8000e43b8001
      result = vrsubhn_u64(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u32(result), 0);
      exp = UINT64_C(0xfffe8000e43b8001);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_379() {

{
   {
      int8x8_t arg1;
      int16x8_t arg2;
      int16x8_t arg3;
      int8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"roundinghighhalf_sub\", fnname = \"vrsubhn_high_s16\", rettype = \"int8x16_t\", argtypes = \"[int8x8_t,int16x8_t,int16x8_t]\", vals = [VectorVal [IntegerVal (-128),IntegerVal (-1),IntegerVal 0,IntegerVal 0,IntegerVal (-128),IntegerVal (-128),IntegerVal 0,IntegerVal 0],VectorVal [IntegerVal (-512),IntegerVal 32767,IntegerVal 32767,IntegerVal (-1),IntegerVal 32767,IntegerVal (-32768),IntegerVal 32767,IntegerVal (-1)],VectorVal [IntegerVal 0,IntegerVal (-32768),IntegerVal (-1),IntegerVal (-32768),IntegerVal (-32768),IntegerVal 32767,IntegerVal 0,IntegerVal 0]], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_s8(UINT64_C(0x000080800000ff80));
      arg2 = vcombine_s16(vcreate_s16(UINT64_C(0xffff7fff7ffffe00)),
                          vcreate_s16(UINT64_C(0xffff7fff80007fff)));
      arg3 = vcombine_s16(vcreate_s16(UINT64_C(0x8000ffff80000000)),
                          vcreate_s16(UINT64_C(0x000000007fff8000)));
      clear_neon_saturated();
      //  Expect: "result" = 00800000808000fe000080800000ff80
      result = vrsubhn_high_s16(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result), 0);
         exp = UINT64_C(0x000080800000ff80);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result), 1);
         exp = UINT64_C(0x00800000808000fe);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_380() {

{
   {
      int16x4_t arg1;
      int32x4_t arg2;
      int32x4_t arg3;
      int16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"roundinghighhalf_sub\", fnname = \"vrsubhn_high_s32\", rettype = \"int16x8_t\", argtypes = \"[int16x4_t,int32x4_t,int32x4_t]\", vals = [VectorVal [IntegerVal (-32768),IntegerVal (-1),IntegerVal (-1),IntegerVal 0],VectorVal [IntegerVal 2147468443,IntegerVal 1061777400,IntegerVal (-1),IntegerVal 32767],VectorVal [IntegerVal (-65536),IntegerVal (-2147464316),IntegerVal 1538059649,IntegerVal (-65536)]], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_s16(UINT64_C(0x0000ffffffff8000));
      arg2 = vcombine_s32(vcreate_s32(UINT64_C(0x3f496ff87fffc49b)),
                          vcreate_s32(UINT64_C(0x00007fffffffffff)));
      arg3 = vcombine_s32(vcreate_s32(UINT64_C(0x80004b84ffff0000)),
                          vcreate_s32(UINT64_C(0xffff00005baced81)));
      clear_neon_saturated();
      //  Expect: "result" = 0001a453bf4980010000ffffffff8000
      result = vrsubhn_high_s32(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 0);
         exp = UINT64_C(0x0000ffffffff8000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 1);
         exp = UINT64_C(0x0001a453bf498001);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_381() {

{
   {
      int32x2_t arg1;
      int64x2_t arg2;
      int64x2_t arg3;
      int32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"roundinghighhalf_sub\", fnname = \"vrsubhn_high_s64\", rettype = \"int32x4_t\", argtypes = \"[int32x2_t,int64x2_t,int64x2_t]\", vals = [VectorVal [IntegerVal 1886322688,IntegerVal (-2147450880)],VectorVal [IntegerVal 9223144959786385407,IntegerVal (-9223372034707324928)],VectorVal [IntegerVal (-9223231295690174885),IntegerVal (-9136537006539571200)]], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_s32(UINT64_C(0x80008000706f0000));
      arg2 = vcombine_s64(vcreate_s64(UINT64_C(0x7fff317980007fff)),
                          vcreate_s64(UINT64_C(0x800000007fff8000)));
      arg3 = vcombine_s64(vcreate_s64(UINT64_C(0x80008000db1f0e5b)),
                          vcreate_s64(UINT64_C(0x81347fffffff8000)));
      clear_neon_saturated();
      //  Expect: "result" = fecb8001fffeb17980008000706f0000
      result = vrsubhn_high_s64(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 0);
         exp = UINT64_C(0x80008000706f0000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 1);
         exp = UINT64_C(0xfecb8001fffeb179);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_382() {

{
   {
      uint8x8_t arg1;
      uint16x8_t arg2;
      uint16x8_t arg3;
      uint8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"roundinghighhalf_sub\", fnname = \"vrsubhn_high_u16\", rettype = \"uint8x16_t\", argtypes = \"[uint8x8_t,uint16x8_t,uint16x8_t]\", vals = [VectorVal [IntegerVal 142,IntegerVal 128,IntegerVal 166,IntegerVal 0,IntegerVal 255,IntegerVal 127,IntegerVal 127,IntegerVal 127],VectorVal [IntegerVal 39927,IntegerVal 32768,IntegerVal 36362,IntegerVal 0,IntegerVal 0,IntegerVal 0,IntegerVal 32768,IntegerVal 65535],VectorVal [IntegerVal 0,IntegerVal 64941,IntegerVal 0,IntegerVal 40045,IntegerVal 0,IntegerVal 32767,IntegerVal 32767,IntegerVal 32767]], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_u8(UINT64_C(0x7f7f7fff00a6808e));
      arg2 = vcombine_u16(vcreate_u16(UINT64_C(0x00008e0a80009bf7)),
                          vcreate_u16(UINT64_C(0xffff800000000000)));
      arg3 = vcombine_u16(vcreate_u16(UINT64_C(0x9c6d0000fdad0000)),
                          vcreate_u16(UINT64_C(0x7fff7fff7fff0000)));
      clear_neon_saturated();
      //  Expect: "result" = 80008000648e829c7f7f7fff00a6808e
      result = vrsubhn_high_u16(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 0);
         exp = UINT64_C(0x7f7f7fff00a6808e);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 1);
         exp = UINT64_C(0x80008000648e829c);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_383() {

{
   {
      uint16x4_t arg1;
      uint32x4_t arg2;
      uint32x4_t arg3;
      uint16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"roundinghighhalf_sub\", fnname = \"vrsubhn_high_u32\", rettype = \"uint16x8_t\", argtypes = \"[uint16x4_t,uint32x4_t,uint32x4_t]\", vals = [VectorVal [IntegerVal 65535,IntegerVal 32768,IntegerVal 32768,IntegerVal 32768],VectorVal [IntegerVal 177307648,IntegerVal 0,IntegerVal 2147483647,IntegerVal 573210624],VectorVal [IntegerVal 2147528347,IntegerVal 2147450879,IntegerVal 750551040,IntegerVal 2147483647]], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_u16(UINT64_C(0x800080008000ffff));
      arg2 = vcombine_u32(vcreate_u32(UINT64_C(0x000000000a918000)),
                          vcreate_u32(UINT64_C(0x222a80007fffffff)));
      arg3 = vcombine_u32(vcreate_u32(UINT64_C(0x7fff7fff8000ae9b)),
                          vcreate_u32(UINT64_C(0x7fffffff2cbc8000)));
      clear_neon_saturated();
      //  Expect: "result" = a22b534380018a91800080008000ffff
      result = vrsubhn_high_u32(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 0);
         exp = UINT64_C(0x800080008000ffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 1);
         exp = UINT64_C(0xa22b534380018a91);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_384() {

{
   {
      uint32x2_t arg1;
      uint64x2_t arg2;
      uint64x2_t arg3;
      uint32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"roundinghighhalf_sub\", fnname = \"vrsubhn_high_u64\", rettype = \"uint32x4_t\", argtypes = \"[uint32x2_t,uint64x2_t,uint64x2_t]\", vals = [VectorVal [IntegerVal 0,IntegerVal 4294967295],VectorVal [IntegerVal 9223090564025578507,IntegerVal 156159713640447],VectorVal [IntegerVal 140737488355328,IntegerVal 9223231295071453184]], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_u32(UINT64_C(0xffffffff00000000));
      arg2 = vcombine_u64(vcreate_u64(UINT64_C(0x7fff00008000740b)),
                          vcreate_u64(UINT64_C(0x00008e06c4427fff)));
      arg3 = vcombine_u64(vcreate_u64(UINT64_C(0x0000800000000000)),
                          vcreate_u64(UINT64_C(0x7fff7fff00000000)));
      clear_neon_saturated();
      //  Expect: "result" = 80010e087ffe8001ffffffff00000000
      result = vrsubhn_high_u64(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 0);
         exp = UINT64_C(0xffffffff00000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 1);
         exp = UINT64_C(0x80010e087ffe8001);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_385() {

{
   {
      int8x8_t arg1;
      int8x8_t arg2;
      uint8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"ceq\", fnname = \"vceq_s8\", rettype = \"uint8x8_t\", argtypes = \"[int8x8_t,int8x8_t]\", vals = [VectorVal [IntegerVal (-1),IntegerVal (-128),IntegerVal 127,IntegerVal 0,IntegerVal (-128),IntegerVal 10,IntegerVal 31,IntegerVal (-62)],VectorVal [IntegerVal (-128),IntegerVal 75,IntegerVal (-25),IntegerVal (-1),IntegerVal 0,IntegerVal 83,IntegerVal (-1),IntegerVal (-1)]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s8(UINT64_C(0xc21f0a80007f80ff));
      arg2 = vcreate_s8(UINT64_C(0xffff5300ffe74b80));
      clear_neon_saturated();
      //  Expect: "result" = 0000000000000000
      result = vceq_s8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u8(result), 0);
      exp = 0;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_386() {

{
   {
      int16x4_t arg1;
      int16x4_t arg2;
      uint16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"ceq\", fnname = \"vceq_s16\", rettype = \"uint16x4_t\", argtypes = \"[int16x4_t,int16x4_t]\", vals = [VectorVal [IntegerVal (-32768),IntegerVal 32767,IntegerVal (-1),IntegerVal 0],VectorVal [IntegerVal 0,IntegerVal 32767,IntegerVal 31720,IntegerVal (-32768)]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s16(UINT64_C(0x0000ffff7fff8000));
      arg2 = vcreate_s16(UINT64_C(0x80007be87fff0000));
      clear_neon_saturated();
      //  Expect: "result" = 00000000ffff0000
      result = vceq_s16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u16(result), 0);
      exp = UINT64_C(0x00000000ffff0000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_387() {

{
   {
      int32x2_t arg1;
      int32x2_t arg2;
      uint32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"ceq\", fnname = \"vceq_s32\", rettype = \"uint32x2_t\", argtypes = \"[int32x2_t,int32x2_t]\", vals = [VectorVal [IntegerVal (-32769),IntegerVal 32767],VectorVal [IntegerVal (-2147450881),IntegerVal (-1812824065)]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s32(UINT64_C(0x00007fffffff7fff));
      arg2 = vcreate_s32(UINT64_C(0x93f27fff80007fff));
      clear_neon_saturated();
      //  Expect: "result" = 0000000000000000
      result = vceq_s32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u32(result), 0);
      exp = 0;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_388() {

{
   {
      float32x2_t arg1;
      float32x2_t arg2;
      uint32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"ceq\", fnname = \"vceq_f32\", rettype = \"uint32x2_t\", argtypes = \"[float32x2_t,float32x2_t]\", vals = [VectorVal [FloatVal 0.7415538430213928,FloatVal 0.5409243702888489],VectorVal [FloatVal 0.8341127038002014,FloatVal 0.6394548416137695]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_f32(UINT64_C(0x3f0a7a053f3dd679));
      arg2 = vcreate_f32(UINT64_C(0x3f23b3503f558869));
      clear_neon_saturated();
      //  Expect: "result" = 0000000000000000
      result = vceq_f32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u32(result), 0);
      exp = 0;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_389() {

{
   {
      uint8x8_t arg1;
      uint8x8_t arg2;
      uint8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"ceq\", fnname = \"vceq_u8\", rettype = \"uint8x8_t\", argtypes = \"[uint8x8_t,uint8x8_t]\", vals = [VectorVal [IntegerVal 127,IntegerVal 255,IntegerVal 127,IntegerVal 0,IntegerVal 128,IntegerVal 59,IntegerVal 0,IntegerVal 255],VectorVal [IntegerVal 127,IntegerVal 0,IntegerVal 0,IntegerVal 128,IntegerVal 18,IntegerVal 0,IntegerVal 255,IntegerVal 134]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u8(UINT64_C(0xff003b80007fff7f));
      arg2 = vcreate_u8(UINT64_C(0x86ff00128000007f));
      clear_neon_saturated();
      //  Expect: "result" = 00000000000000ff
      result = vceq_u8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u8(result), 0);
      exp = UINT64_C(0x00000000000000ff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_390() {

{
   {
      uint16x4_t arg1;
      uint16x4_t arg2;
      uint16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"ceq\", fnname = \"vceq_u16\", rettype = \"uint16x4_t\", argtypes = \"[uint16x4_t,uint16x4_t]\", vals = [VectorVal [IntegerVal 12549,IntegerVal 37519,IntegerVal 65535,IntegerVal 56246],VectorVal [IntegerVal 0,IntegerVal 1177,IntegerVal 2896,IntegerVal 32485]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u16(UINT64_C(0xdbb6ffff928f3105));
      arg2 = vcreate_u16(UINT64_C(0x7ee50b5004990000));
      clear_neon_saturated();
      //  Expect: "result" = 0000000000000000
      result = vceq_u16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u16(result), 0);
      exp = 0;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_391() {

{
   {
      uint32x2_t arg1;
      uint32x2_t arg2;
      uint32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"ceq\", fnname = \"vceq_u32\", rettype = \"uint32x2_t\", argtypes = \"[uint32x2_t,uint32x2_t]\", vals = [VectorVal [IntegerVal 2147506120,IntegerVal 32768],VectorVal [IntegerVal 4294916148,IntegerVal 0]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u32(UINT64_C(0x00008000800057c8));
      arg2 = vcreate_u32(UINT64_C(0x00000000ffff3834));
      clear_neon_saturated();
      //  Expect: "result" = 0000000000000000
      result = vceq_u32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u32(result), 0);
      exp = 0;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_392() {

{
   {
      poly8x8_t arg1;
      poly8x8_t arg2;
      uint8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"ceq\", fnname = \"vceq_p8\", rettype = \"uint8x8_t\", argtypes = \"[poly8x8_t,poly8x8_t]\", vals = [VectorVal [PolyVal [0,0,1,0,1,1,1,0],PolyVal [1,0,0,0,0,1,0,0],PolyVal [0,1,0,1,1,0,0,0],PolyVal [0,0,1,0,1,0,1,0],PolyVal [1,0,1,1,1,0,0,0],PolyVal [0,1,0,0,0,1,0,1],PolyVal [1,1,0,0,0,1,0,0],PolyVal [1,0,0,1,0,0,0,1]],VectorVal [PolyVal [0,1,0,1,1,0,1,0],PolyVal [0,0,1,1,1,0,0,0],PolyVal [0,0,1,1,1,0,1,0],PolyVal [1,0,1,0,1,0,1,1],PolyVal [1,1,0,1,1,0,1,1],PolyVal [0,0,1,0,1,1,1,0],PolyVal [1,1,0,1,1,0,1,1],PolyVal [0,1,1,0,1,0,1,1]]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_p8(UINT64_C(0x8923a21d541a2174));
      arg2 = vcreate_p8(UINT64_C(0xd6db74dbd55c1c5a));
      clear_neon_saturated();
      //  Expect: "result" = 0000000000000000
      result = vceq_p8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u8(result), 0);
      exp = 0;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_393() {

{
   {
      int8x16_t arg1;
      int8x16_t arg2;
      uint8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"ceq\", fnname = \"vceqq_s8\", rettype = \"uint8x16_t\", argtypes = \"[int8x16_t,int8x16_t]\", vals = [VectorVal [IntegerVal (-128),IntegerVal (-128),IntegerVal (-1),IntegerVal (-1),IntegerVal 127,IntegerVal 80,IntegerVal (-48),IntegerVal (-128),IntegerVal (-1),IntegerVal (-39),IntegerVal (-1),IntegerVal (-1),IntegerVal 88,IntegerVal 0,IntegerVal (-128),IntegerVal 127],VectorVal [IntegerVal (-1),IntegerVal (-60),IntegerVal (-1),IntegerVal 0,IntegerVal 27,IntegerVal 0,IntegerVal (-128),IntegerVal 127,IntegerVal 97,IntegerVal 93,IntegerVal 124,IntegerVal (-1),IntegerVal 0,IntegerVal 127,IntegerVal 0,IntegerVal (-80)]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s8(vcreate_s8(UINT64_C(0x80d0507fffff8080)),
                         vcreate_s8(UINT64_C(0x7f800058ffffd9ff)));
      arg2 = vcombine_s8(vcreate_s8(UINT64_C(0x7f80001b00ffc4ff)),
                         vcreate_s8(UINT64_C(0xb0007f00ff7c5d61)));
      clear_neon_saturated();
      //  Expect: "result" = 00000000ff0000000000000000ff0000
      result = vceqq_s8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 0);
         exp = UINT64_C(0x0000000000ff0000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 1);
         exp = UINT64_C(0x00000000ff000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_394() {

{
   {
      int16x8_t arg1;
      int16x8_t arg2;
      uint16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"ceq\", fnname = \"vceqq_s16\", rettype = \"uint16x8_t\", argtypes = \"[int16x8_t,int16x8_t]\", vals = [VectorVal [IntegerVal 0,IntegerVal 32767,IntegerVal (-32768),IntegerVal (-10705),IntegerVal 6825,IntegerVal (-1),IntegerVal (-1),IntegerVal (-22381)],VectorVal [IntegerVal (-15144),IntegerVal 0,IntegerVal 32767,IntegerVal (-1),IntegerVal (-1),IntegerVal 32767,IntegerVal 32767,IntegerVal (-4492)]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s16(vcreate_s16(UINT64_C(0xd62f80007fff0000)),
                          vcreate_s16(UINT64_C(0xa893ffffffff1aa9)));
      arg2 = vcombine_s16(vcreate_s16(UINT64_C(0xffff7fff0000c4d8)),
                          vcreate_s16(UINT64_C(0xee747fff7fffffff)));
      clear_neon_saturated();
      //  Expect: "result" = 00000000000000000000000000000000
      result = vceqq_s16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 0);
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 1);
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_395() {

{
   {
      int32x4_t arg1;
      int32x4_t arg2;
      uint32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"ceq\", fnname = \"vceqq_s32\", rettype = \"uint32x4_t\", argtypes = \"[int32x4_t,int32x4_t]\", vals = [VectorVal [IntegerVal 58816,IntegerVal 2147418112,IntegerVal (-1282965504),IntegerVal 2147450879],VectorVal [IntegerVal 65535,IntegerVal (-2147450881),IntegerVal 0,IntegerVal 2147418112]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s32(vcreate_s32(UINT64_C(0x7fff00000000e5c0)),
                          vcreate_s32(UINT64_C(0x7fff7fffb3878000)));
      arg2 = vcombine_s32(vcreate_s32(UINT64_C(0x80007fff0000ffff)),
                          vcreate_s32(UINT64_C(0x7fff000000000000)));
      clear_neon_saturated();
      //  Expect: "result" = 00000000000000000000000000000000
      result = vceqq_s32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 0);
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 1);
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_396() {

{
   {
      float32x4_t arg1;
      float32x4_t arg2;
      uint32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"ceq\", fnname = \"vceqq_f32\", rettype = \"uint32x4_t\", argtypes = \"[float32x4_t,float32x4_t]\", vals = [VectorVal [FloatVal 0.3720451593399048,FloatVal 0.966404139995575,FloatVal 0.4019153118133545,FloatVal 0.6189365386962891],VectorVal [FloatVal 1.122206449508667e-2,FloatVal 0.8974215388298035,FloatVal 0.4048483967781067,FloatVal 0.12181311845779419]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_f32(vcreate_f32(UINT64_C(0x3f7766433ebe7cb4)),
                          vcreate_f32(UINT64_C(0x3f1e72a03ecdc7d8)));
      arg2 = vcombine_f32(vcreate_f32(UINT64_C(0x3f65bd6b3c37dcc0)),
                          vcreate_f32(UINT64_C(0x3df979283ecf484a)));
      clear_neon_saturated();
      //  Expect: "result" = 00000000000000000000000000000000
      result = vceqq_f32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 0);
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 1);
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_397() {

{
   {
      uint8x16_t arg1;
      uint8x16_t arg2;
      uint8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"ceq\", fnname = \"vceqq_u8\", rettype = \"uint8x16_t\", argtypes = \"[uint8x16_t,uint8x16_t]\", vals = [VectorVal [IntegerVal 127,IntegerVal 255,IntegerVal 128,IntegerVal 128,IntegerVal 0,IntegerVal 255,IntegerVal 128,IntegerVal 128,IntegerVal 255,IntegerVal 127,IntegerVal 255,IntegerVal 0,IntegerVal 79,IntegerVal 255,IntegerVal 150,IntegerVal 127],VectorVal [IntegerVal 0,IntegerVal 128,IntegerVal 57,IntegerVal 128,IntegerVal 255,IntegerVal 127,IntegerVal 128,IntegerVal 255,IntegerVal 127,IntegerVal 255,IntegerVal 128,IntegerVal 0,IntegerVal 127,IntegerVal 128,IntegerVal 127,IntegerVal 0]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u8(vcreate_u8(UINT64_C(0x8080ff008080ff7f)),
                         vcreate_u8(UINT64_C(0x7f96ff4f00ff7fff)));
      arg2 = vcombine_u8(vcreate_u8(UINT64_C(0xff807fff80398000)),
                         vcreate_u8(UINT64_C(0x007f807f0080ff7f)));
      clear_neon_saturated();
      //  Expect: "result" = 00000000ff00000000ff0000ff000000
      result = vceqq_u8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 0);
         exp = UINT64_C(0x00ff0000ff000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 1);
         exp = UINT64_C(0x00000000ff000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_398() {

{
   {
      uint16x8_t arg1;
      uint16x8_t arg2;
      uint16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"ceq\", fnname = \"vceqq_u16\", rettype = \"uint16x8_t\", argtypes = \"[uint16x8_t,uint16x8_t]\", vals = [VectorVal [IntegerVal 32767,IntegerVal 32768,IntegerVal 32768,IntegerVal 32767,IntegerVal 36014,IntegerVal 0,IntegerVal 65535,IntegerVal 0],VectorVal [IntegerVal 32767,IntegerVal 52218,IntegerVal 32768,IntegerVal 0,IntegerVal 32768,IntegerVal 32768,IntegerVal 0,IntegerVal 0]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u16(vcreate_u16(UINT64_C(0x7fff800080007fff)),
                          vcreate_u16(UINT64_C(0x0000ffff00008cae)));
      arg2 = vcombine_u16(vcreate_u16(UINT64_C(0x00008000cbfa7fff)),
                          vcreate_u16(UINT64_C(0x0000000080008000)));
      clear_neon_saturated();
      //  Expect: "result" = ffff0000000000000000ffff0000ffff
      result = vceqq_u16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 0);
         exp = UINT64_C(0x0000ffff0000ffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 1);
         exp = UINT64_C(0xffff000000000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_399() {

{
   {
      uint32x4_t arg1;
      uint32x4_t arg2;
      uint32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"ceq\", fnname = \"vceqq_u32\", rettype = \"uint32x4_t\", argtypes = \"[uint32x4_t,uint32x4_t]\", vals = [VectorVal [IntegerVal 4294934528,IntegerVal 4294934528,IntegerVal 2296152064,IntegerVal 2777219072],VectorVal [IntegerVal 2147418112,IntegerVal 4294967295,IntegerVal 4294934528,IntegerVal 2147460039]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u32(vcreate_u32(UINT64_C(0xffff8000ffff8000)),
                          vcreate_u32(UINT64_C(0xa589000088dc8000)));
      arg2 = vcombine_u32(vcreate_u32(UINT64_C(0xffffffff7fff0000)),
                          vcreate_u32(UINT64_C(0x7fffa3c7ffff8000)));
      clear_neon_saturated();
      //  Expect: "result" = 00000000000000000000000000000000
      result = vceqq_u32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 0);
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 1);
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_400() {

{
   {
      poly8x16_t arg1;
      poly8x16_t arg2;
      uint8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"ceq\", fnname = \"vceqq_p8\", rettype = \"uint8x16_t\", argtypes = \"[poly8x16_t,poly8x16_t]\", vals = [VectorVal [PolyVal [0,0,1,1,1,0,0,1],PolyVal [0,0,1,1,0,1,1,1],PolyVal [1,1,0,0,0,1,0,0],PolyVal [0,0,0,0,0,0,0,1],PolyVal [1,1,0,1,1,1,0,0],PolyVal [1,1,0,0,0,1,1,1],PolyVal [0,0,1,1,1,0,0,1],PolyVal [1,1,1,1,1,1,1,1],PolyVal [1,0,0,1,1,1,1,1],PolyVal [1,1,1,0,0,1,0,1],PolyVal [1,0,0,1,0,0,0,1],PolyVal [1,1,0,0,1,1,0,0],PolyVal [1,1,1,0,1,0,0,1],PolyVal [0,1,1,1,0,0,1,1],PolyVal [0,1,0,1,1,1,1,0],PolyVal [0,0,1,0,0,0,0,0]],VectorVal [PolyVal [1,1,0,1,1,0,0,1],PolyVal [0,0,1,0,1,0,0,0],PolyVal [1,1,1,1,1,1,1,1],PolyVal [0,0,1,1,1,1,1,1],PolyVal [1,1,1,1,0,0,0,1],PolyVal [0,0,1,1,1,1,1,1],PolyVal [0,0,1,0,0,1,0,0],PolyVal [1,0,1,0,1,0,0,1],PolyVal [1,0,1,1,1,1,1,1],PolyVal [0,1,0,0,1,1,0,1],PolyVal [1,0,1,0,0,1,0,0],PolyVal [1,0,0,1,0,1,1,1],PolyVal [1,1,1,1,0,1,1,1],PolyVal [0,1,0,0,0,1,1,1],PolyVal [0,0,1,0,1,1,0,0],PolyVal [1,1,0,1,1,1,0,0]]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_p8(vcreate_p8(UINT64_C(0xff9ce33b8023ec9c)),
                         vcreate_p8(UINT64_C(0x047ace973389a7f9)));
      arg2 = vcombine_p8(vcreate_p8(UINT64_C(0x9524fc8ffcff149b)),
                         vcreate_p8(UINT64_C(0x3b34e2efe925b2fd)));
      clear_neon_saturated();
      //  Expect: "result" = 00000000000000000000000000000000
      result = vceqq_p8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 0);
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 1);
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_401() {

{
   {
      int64x1_t arg1;
      int64x1_t arg2;
      uint64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"ceq\", fnname = \"vceq_s64\", rettype = \"uint64x1_t\", argtypes = \"[int64x1_t,int64x1_t]\", vals = [VectorVal [IntegerVal (-219749854183424)],VectorVal [IntegerVal (-9223231303661343310)]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s64(UINT64_C(0xffff382380008000));
      arg2 = vcreate_s64(UINT64_C(0x80007fff0000adb2));
      clear_neon_saturated();
      //  Expect: "result" = 0000000000000000
      result = vceq_s64(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(result, 0);
      exp = 0;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_402() {

{
   {
      uint64x1_t arg1;
      uint64x1_t arg2;
      uint64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"ceq\", fnname = \"vceq_u64\", rettype = \"uint64x1_t\", argtypes = \"[uint64x1_t,uint64x1_t]\", vals = [VectorVal [IntegerVal 9223090564386577711],VectorVal [IntegerVal 281472829292543]], start_saturated = True}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u64(UINT64_C(0x7fff00009584dd2f));
      arg2 = vcreate_u64(UINT64_C(0x0000ffff8000ffff));
      set_neon_saturated();
      //  Expect: "result" = 0000000000000000
      result = vceq_u64(arg1, arg2);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      got = vget_lane_u64(result, 0);
      exp = 0;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_403() {

{
   {
      float64x1_t arg1;
      float64x1_t arg2;
      uint64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"ceq\", fnname = \"vceq_f64\", rettype = \"uint64x1_t\", argtypes = \"[float64x1_t,float64x1_t]\", vals = [VectorVal [FloatVal 0.9973723897793982],VectorVal [FloatVal 0.6904952465761311]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_f64(UINT64_C(0x3fefea79808125ee));
      arg2 = vcreate_f64(UINT64_C(0x3fe618897cc2d066));
      clear_neon_saturated();
      //  Expect: "result" = 0000000000000000
      result = vceq_f64(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(result, 0);
      exp = 0;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_404() {

{
   {
      int64x2_t arg1;
      int64x2_t arg2;
      uint64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"ceq\", fnname = \"vceqq_s64\", rettype = \"uint64x2_t\", argtypes = \"[int64x2_t,int64x2_t]\", vals = [VectorVal [IntegerVal (-140735340817641),IntegerVal 9223090564025548800],VectorVal [IntegerVal (-9223090564025524127),IntegerVal 6875026310452738476]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s64(vcreate_s64(UINT64_C(0xffff80008000d317)),
                          vcreate_s64(UINT64_C(0x7fff000080000000)));
      arg2 = vcombine_s64(vcreate_s64(UINT64_C(0x8000ffff80006061)),
                          vcreate_s64(UINT64_C(0x5f690000fffff9ac)));
      clear_neon_saturated();
      //  Expect: "result" = 00000000000000000000000000000000
      result = vceqq_s64(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 0);
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 1);
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_405() {

{
   {
      uint64x2_t arg1;
      uint64x2_t arg2;
      uint64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"ceq\", fnname = \"vceqq_u64\", rettype = \"uint64x2_t\", argtypes = \"[uint64x2_t,uint64x2_t]\", vals = [VectorVal [IntegerVal 9223578858857489908,IntegerVal 13762578248779202560],VectorVal [IntegerVal 9223372032559849338,IntegerVal 18446631074865184767]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u64(vcreate_u64(UINT64_C(0x8000bc1a8000e5f4)),
                          vcreate_u64(UINT64_C(0xbefe800000008000)));
      arg2 = vcombine_u64(vcreate_u64(UINT64_C(0x7fffffff00009f7a)),
                          vcreate_u64(UINT64_C(0xffff993a68057fff)));
      clear_neon_saturated();
      //  Expect: "result" = 00000000000000000000000000000000
      result = vceqq_u64(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 0);
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 1);
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_406() {

{
   {
      float64x2_t arg1;
      float64x2_t arg2;
      uint64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"ceq\", fnname = \"vceqq_f64\", rettype = \"uint64x2_t\", argtypes = \"[float64x2_t,float64x2_t]\", vals = [VectorVal [FloatVal 0.8856813185513182,FloatVal 0.5522779331450832],VectorVal [FloatVal 0.21798700252556724,FloatVal 0.5484680458256258]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_f64(vcreate_f64(UINT64_C(0x3fec5780593b64ec)),
                          vcreate_f64(UINT64_C(0x3fe1ac42c5a523b1)));
      arg2 = vcombine_f64(vcreate_f64(UINT64_C(0x3fcbe6ff836672e0)),
                          vcreate_f64(UINT64_C(0x3fe18d0cdbf71b61)));
      clear_neon_saturated();
      //  Expect: "result" = 00000000000000000000000000000000
      result = vceqq_f64(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 0);
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 1);
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_407() {

{
   {
      int64_t arg1;
      int64_t arg2;
      uint64_t result;
      char* str1 = "ReproInfo2 {semantics = \"ceq\", fnname = \"vceqd_s64\", rettype = \"uint64_t\", argtypes = \"[int64_t,int64_t]\", vals = [IntegerVal 9223118311661795647,IntegerVal (-5682135350563095517)], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = INT64_C(9223118311661795647);
      arg2 = INT64_C(-5682135350563095517);
      clear_neon_saturated();
      //  Expect: "result" = 0000000000000000
      result = vceqd_s64(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = 0;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_408() {

{
   {
      uint64_t arg1;
      uint64_t arg2;
      uint64_t result;
      char* str1 = "ReproInfo2 {semantics = \"ceq\", fnname = \"vceqd_u64\", rettype = \"uint64_t\", argtypes = \"[uint64_t,uint64_t]\", vals = [IntegerVal 18446603335542505472,IntegerVal 9223231299366453247], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = UINT64_C(0xffff7fffd78c0000);
      arg2 = UINT64_C(0x7fff800000007fff);
      clear_neon_saturated();
      //  Expect: "result" = 0000000000000000
      result = vceqd_u64(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = 0;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_409() {

{
   {
      float64_t arg1;
      float64_t arg2;
      uint64_t result;
      char* str1 = "ReproInfo2 {semantics = \"ceq\", fnname = \"vceqd_f64\", rettype = \"uint64_t\", argtypes = \"[float64_t,float64_t]\", vals = [FloatVal 0.29243191873812024,FloatVal 0.3581657798051834], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = 0.29243191873812024;
      arg2 = 0.3581657798051834;
      clear_neon_saturated();
      //  Expect: "result" = 0000000000000000
      result = vceqd_f64(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = 0;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_410() {

{
   {
      float32_t arg1;
      float32_t arg2;
      uint32_t result;
      char* str1 = "ReproInfo2 {semantics = \"ceq\", fnname = \"vceqs_f32\", rettype = \"uint32_t\", argtypes = \"[float32_t,float32_t]\", vals = [FloatVal 0.4552466869354248,FloatVal 0.4301597476005554], start_saturated = False}";
      int reported = 0;
      uint32_t got;
      uint32_t exp;
      arg1 = ((float32_t) 0.4552466869354248);
      arg2 = ((float32_t) 0.4301597476005554);
      clear_neon_saturated();
      //  Expect: "result" = 00000000
      result = vceqs_f32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = 0;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIu32 " Got: %" PRIu32 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_411() {

{
   {
      int8x8_t arg1;
      int8x8_t arg2;
      uint8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"cge\", fnname = \"vcge_s8\", rettype = \"uint8x8_t\", argtypes = \"[int8x8_t,int8x8_t]\", vals = [VectorVal [IntegerVal (-1),IntegerVal 127,IntegerVal (-1),IntegerVal 49,IntegerVal (-1),IntegerVal 127,IntegerVal (-1),IntegerVal 56],VectorVal [IntegerVal (-1),IntegerVal (-1),IntegerVal (-66),IntegerVal (-1),IntegerVal 127,IntegerVal 0,IntegerVal (-128),IntegerVal (-128)]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s8(UINT64_C(0x38ff7fff31ff7fff));
      arg2 = vcreate_s8(UINT64_C(0x8080007fffbeffff));
      clear_neon_saturated();
      //  Expect: "result" = ffffff00ffffffff
      result = vcge_s8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u8(result), 0);
      exp = UINT64_C(0xffffff00ffffffff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_412() {

{
   {
      int16x4_t arg1;
      int16x4_t arg2;
      uint16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"cge\", fnname = \"vcge_s16\", rettype = \"uint16x4_t\", argtypes = \"[int16x4_t,int16x4_t]\", vals = [VectorVal [IntegerVal (-1),IntegerVal (-1),IntegerVal 1033,IntegerVal (-1)],VectorVal [IntegerVal 32767,IntegerVal (-32768),IntegerVal (-1),IntegerVal (-32768)]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s16(UINT64_C(0xffff0409ffffffff));
      arg2 = vcreate_s16(UINT64_C(0x8000ffff80007fff));
      clear_neon_saturated();
      //  Expect: "result" = ffffffffffff0000
      result = vcge_s16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u16(result), 0);
      exp = UINT64_C(0xffffffffffff0000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_413() {

{
   {
      int32x2_t arg1;
      int32x2_t arg2;
      uint32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"cge\", fnname = \"vcge_s32\", rettype = \"uint32x2_t\", argtypes = \"[int32x2_t,int32x2_t]\", vals = [VectorVal [IntegerVal (-2147439654),IntegerVal 32767],VectorVal [IntegerVal 2147449882,IntegerVal 32767]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s32(UINT64_C(0x00007fff8000abda));
      arg2 = vcreate_s32(UINT64_C(0x00007fff7fff7c1a));
      clear_neon_saturated();
      //  Expect: "result" = ffffffff00000000
      result = vcge_s32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u32(result), 0);
      exp = UINT64_C(0xffffffff00000000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_414() {

{
   {
      float32x2_t arg1;
      float32x2_t arg2;
      uint32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"cge\", fnname = \"vcge_f32\", rettype = \"uint32x2_t\", argtypes = \"[float32x2_t,float32x2_t]\", vals = [VectorVal [FloatVal 0.23078715801239014,FloatVal 0.8321971297264099],VectorVal [FloatVal 1.2592792510986328e-2,FloatVal 0.8450909852981567]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_f32(UINT64_C(0x3f550adf3e6c5378));
      arg2 = vcreate_f32(UINT64_C(0x3f5857e23c4e5200));
      clear_neon_saturated();
      //  Expect: "result" = 00000000ffffffff
      result = vcge_f32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u32(result), 0);
      exp = UINT64_C(0x00000000ffffffff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_415() {

{
   {
      uint8x8_t arg1;
      uint8x8_t arg2;
      uint8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"cge\", fnname = \"vcge_u8\", rettype = \"uint8x8_t\", argtypes = \"[uint8x8_t,uint8x8_t]\", vals = [VectorVal [IntegerVal 127,IntegerVal 127,IntegerVal 156,IntegerVal 128,IntegerVal 127,IntegerVal 255,IntegerVal 127,IntegerVal 127],VectorVal [IntegerVal 0,IntegerVal 127,IntegerVal 255,IntegerVal 69,IntegerVal 128,IntegerVal 0,IntegerVal 0,IntegerVal 255]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u8(UINT64_C(0x7f7fff7f809c7f7f));
      arg2 = vcreate_u8(UINT64_C(0xff00008045ff7f00));
      clear_neon_saturated();
      //  Expect: "result" = 00ffff00ff00ffff
      result = vcge_u8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u8(result), 0);
      exp = UINT64_C(0x00ffff00ff00ffff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_416() {

{
   {
      uint16x4_t arg1;
      uint16x4_t arg2;
      uint16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"cge\", fnname = \"vcge_u16\", rettype = \"uint16x4_t\", argtypes = \"[uint16x4_t,uint16x4_t]\", vals = [VectorVal [IntegerVal 32767,IntegerVal 65535,IntegerVal 36642,IntegerVal 65535],VectorVal [IntegerVal 32767,IntegerVal 0,IntegerVal 14179,IntegerVal 32767]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u16(UINT64_C(0xffff8f22ffff7fff));
      arg2 = vcreate_u16(UINT64_C(0x7fff376300007fff));
      clear_neon_saturated();
      //  Expect: "result" = ffffffffffffffff
      result = vcge_u16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u16(result), 0);
      exp = UINT64_C(0xffffffffffffffff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_417() {

{
   {
      uint32x2_t arg1;
      uint32x2_t arg2;
      uint32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"cge\", fnname = \"vcge_u32\", rettype = \"uint32x2_t\", argtypes = \"[uint32x2_t,uint32x2_t]\", vals = [VectorVal [IntegerVal 65535,IntegerVal 2147508900],VectorVal [IntegerVal 327352320,IntegerVal 2147483648]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u32(UINT64_C(0x800062a40000ffff));
      arg2 = vcreate_u32(UINT64_C(0x8000000013830000));
      clear_neon_saturated();
      //  Expect: "result" = ffffffff00000000
      result = vcge_u32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u32(result), 0);
      exp = UINT64_C(0xffffffff00000000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_418() {

{
   {
      int8x16_t arg1;
      int8x16_t arg2;
      uint8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"cge\", fnname = \"vcgeq_s8\", rettype = \"uint8x16_t\", argtypes = \"[int8x16_t,int8x16_t]\", vals = [VectorVal [IntegerVal (-1),IntegerVal 127,IntegerVal 127,IntegerVal (-128),IntegerVal (-128),IntegerVal 127,IntegerVal 127,IntegerVal (-1),IntegerVal (-128),IntegerVal 127,IntegerVal 0,IntegerVal (-128),IntegerVal 0,IntegerVal 79,IntegerVal 0,IntegerVal (-37)],VectorVal [IntegerVal (-1),IntegerVal (-128),IntegerVal 127,IntegerVal 33,IntegerVal 18,IntegerVal 0,IntegerVal (-45),IntegerVal (-128),IntegerVal 127,IntegerVal (-128),IntegerVal 0,IntegerVal 127,IntegerVal 53,IntegerVal 0,IntegerVal 22,IntegerVal (-1)]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s8(vcreate_s8(UINT64_C(0xff7f7f80807f7fff)),
                         vcreate_s8(UINT64_C(0xdb004f0080007f80)));
      arg2 = vcombine_s8(vcreate_s8(UINT64_C(0x80d30012217f80ff)),
                         vcreate_s8(UINT64_C(0xff1600357f00807f)));
      clear_neon_saturated();
      //  Expect: "result" = 0000ff0000ffff00ffffff0000ffffff
      result = vcgeq_s8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 0);
         exp = UINT64_C(0xffffff0000ffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 1);
         exp = UINT64_C(0x0000ff0000ffff00);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_419() {

{
   {
      int16x8_t arg1;
      int16x8_t arg2;
      uint16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"cge\", fnname = \"vcgeq_s16\", rettype = \"uint16x8_t\", argtypes = \"[int16x8_t,int16x8_t]\", vals = [VectorVal [IntegerVal 5414,IntegerVal 871,IntegerVal 0,IntegerVal 0,IntegerVal (-1),IntegerVal (-32768),IntegerVal (-1),IntegerVal (-32768)],VectorVal [IntegerVal (-1),IntegerVal 0,IntegerVal 32767,IntegerVal (-1),IntegerVal (-1),IntegerVal 0,IntegerVal (-1),IntegerVal 32767]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s16(vcreate_s16(UINT64_C(0x0000000003671526)),
                          vcreate_s16(UINT64_C(0x8000ffff8000ffff)));
      arg2 = vcombine_s16(vcreate_s16(UINT64_C(0xffff7fff0000ffff)),
                          vcreate_s16(UINT64_C(0x7fffffff0000ffff)));
      clear_neon_saturated();
      //  Expect: "result" = 0000ffff0000ffffffff0000ffffffff
      result = vcgeq_s16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 0);
         exp = UINT64_C(0xffff0000ffffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 1);
         exp = UINT64_C(0x0000ffff0000ffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_420() {

{
   {
      int32x4_t arg1;
      int32x4_t arg2;
      uint32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"cge\", fnname = \"vcgeq_s32\", rettype = \"uint32x4_t\", argtypes = \"[int32x4_t,int32x4_t]\", vals = [VectorVal [IntegerVal (-425984000),IntegerVal 32767,IntegerVal 1883531172,IntegerVal (-2147450881)],VectorVal [IntegerVal 54848,IntegerVal (-57151),IntegerVal (-2147418113),IntegerVal 65535]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s32(vcreate_s32(UINT64_C(0x00007fffe69c0000)),
                          vcreate_s32(UINT64_C(0x80007fff704467a4)));
      arg2 = vcombine_s32(vcreate_s32(UINT64_C(0xffff20c10000d640)),
                          vcreate_s32(UINT64_C(0x0000ffff8000ffff)));
      clear_neon_saturated();
      //  Expect: "result" = 00000000ffffffffffffffff00000000
      result = vcgeq_s32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 0);
         exp = UINT64_C(0xffffffff00000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 1);
         exp = UINT64_C(0x00000000ffffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_421() {

{
   {
      float32x4_t arg1;
      float32x4_t arg2;
      uint32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"cge\", fnname = \"vcgeq_f32\", rettype = \"uint32x4_t\", argtypes = \"[float32x4_t,float32x4_t]\", vals = [VectorVal [FloatVal 3.410017490386963e-2,FloatVal 0.8852890729904175,FloatVal 0.8844092488288879,FloatVal 0.6028785705566406],VectorVal [FloatVal 0.9062389731407166,FloatVal 0.32099467515945435,FloatVal 0.17679059505462646,FloatVal 0.7122007012367249]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_f32(vcreate_f32(UINT64_C(0x3f62a24e3d0baca0)),
                          vcreate_f32(UINT64_C(0x3f1a56403f6268a5)));
      arg2 = vcombine_f32(vcreate_f32(UINT64_C(0x3ea4596a3f67ff47)),
                          vcreate_f32(UINT64_C(0x3f3652c93e350898)));
      clear_neon_saturated();
      //  Expect: "result" = 00000000ffffffffffffffff00000000
      result = vcgeq_f32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 0);
         exp = UINT64_C(0xffffffff00000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 1);
         exp = UINT64_C(0x00000000ffffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_422() {

{
   {
      uint8x16_t arg1;
      uint8x16_t arg2;
      uint8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"cge\", fnname = \"vcgeq_u8\", rettype = \"uint8x16_t\", argtypes = \"[uint8x16_t,uint8x16_t]\", vals = [VectorVal [IntegerVal 127,IntegerVal 0,IntegerVal 127,IntegerVal 0,IntegerVal 255,IntegerVal 0,IntegerVal 0,IntegerVal 128,IntegerVal 127,IntegerVal 255,IntegerVal 128,IntegerVal 128,IntegerVal 128,IntegerVal 127,IntegerVal 255,IntegerVal 255],VectorVal [IntegerVal 0,IntegerVal 128,IntegerVal 127,IntegerVal 221,IntegerVal 15,IntegerVal 190,IntegerVal 174,IntegerVal 255,IntegerVal 128,IntegerVal 255,IntegerVal 128,IntegerVal 128,IntegerVal 127,IntegerVal 128,IntegerVal 155,IntegerVal 127]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u8(vcreate_u8(UINT64_C(0x800000ff007f007f)),
                         vcreate_u8(UINT64_C(0xffff7f808080ff7f)));
      arg2 = vcombine_u8(vcreate_u8(UINT64_C(0xffaebe0fdd7f8000)),
                         vcreate_u8(UINT64_C(0x7f9b807f8080ff80)));
      clear_neon_saturated();
      //  Expect: "result" = ffff00ffffffff00000000ff00ff00ff
      result = vcgeq_u8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 0);
         exp = UINT64_C(0x000000ff00ff00ff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 1);
         exp = UINT64_C(0xffff00ffffffff00);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_423() {

{
   {
      uint16x8_t arg1;
      uint16x8_t arg2;
      uint16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"cge\", fnname = \"vcgeq_u16\", rettype = \"uint16x8_t\", argtypes = \"[uint16x8_t,uint16x8_t]\", vals = [VectorVal [IntegerVal 35118,IntegerVal 32768,IntegerVal 65535,IntegerVal 32767,IntegerVal 32767,IntegerVal 65535,IntegerVal 0,IntegerVal 32767],VectorVal [IntegerVal 41215,IntegerVal 32767,IntegerVal 65535,IntegerVal 32768,IntegerVal 32768,IntegerVal 32768,IntegerVal 32767,IntegerVal 65535]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u16(vcreate_u16(UINT64_C(0x7fffffff8000892e)),
                          vcreate_u16(UINT64_C(0x7fff0000ffff7fff)));
      arg2 = vcombine_u16(vcreate_u16(UINT64_C(0x8000ffff7fffa0ff)),
                          vcreate_u16(UINT64_C(0xffff7fff80008000)));
      clear_neon_saturated();
      //  Expect: "result" = 00000000ffff00000000ffffffff0000
      result = vcgeq_u16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 0);
         exp = UINT64_C(0x0000ffffffff0000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 1);
         exp = UINT64_C(0x00000000ffff0000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_424() {

{
   {
      uint32x4_t arg1;
      uint32x4_t arg2;
      uint32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"cge\", fnname = \"vcgeq_u32\", rettype = \"uint32x4_t\", argtypes = \"[uint32x4_t,uint32x4_t]\", vals = [VectorVal [IntegerVal 2147419759,IntegerVal 2147516416,IntegerVal 3037396991,IntegerVal 4294934527],VectorVal [IntegerVal 4294943723,IntegerVal 2147546278,IntegerVal 4294934528,IntegerVal 4294934528]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u32(vcreate_u32(UINT64_C(0x800080007fff066f)),
                          vcreate_u32(UINT64_C(0xffff7fffb50affff)));
      arg2 = vcombine_u32(vcreate_u32(UINT64_C(0x8000f4a6ffffa3eb)),
                          vcreate_u32(UINT64_C(0xffff8000ffff8000)));
      clear_neon_saturated();
      //  Expect: "result" = 00000000000000000000000000000000
      result = vcgeq_u32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 0);
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 1);
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_425() {

{
   {
      int64x1_t arg1;
      int64x1_t arg2;
      uint64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"cge\", fnname = \"vcge_s64\", rettype = \"uint64x1_t\", argtypes = \"[int64x1_t,int64x1_t]\", vals = [VectorVal [IntegerVal (-2406645760)],VectorVal [IntegerVal 9223231302935379968]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s64(UINT64_C(0xffffffff708d8000));
      arg2 = vcreate_s64(UINT64_C(0x7fff8000d4ba0000));
      clear_neon_saturated();
      //  Expect: "result" = 0000000000000000
      result = vcge_s64(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(result, 0);
      exp = 0;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_426() {

{
   {
      uint64x1_t arg1;
      uint64x1_t arg2;
      uint64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"cge\", fnname = \"vcge_u64\", rettype = \"uint64x1_t\", argtypes = \"[uint64x1_t,uint64x1_t]\", vals = [VectorVal [IntegerVal 18446462599640612864],VectorVal [IntegerVal 2147516416]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u64(UINT64_C(0xffff0000361b8000));
      arg2 = vcreate_u64(UINT64_C(0x0000000080008000));
      clear_neon_saturated();
      //  Expect: "result" = ffffffffffffffff
      result = vcge_u64(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(result, 0);
      exp = UINT64_C(0xffffffffffffffff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_427() {

{
   {
      float64x1_t arg1;
      float64x1_t arg2;
      uint64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"cge\", fnname = \"vcge_f64\", rettype = \"uint64x1_t\", argtypes = \"[float64x1_t,float64x1_t]\", vals = [VectorVal [FloatVal 0.8997001964820792],VectorVal [FloatVal 0.35468495694778623]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_f64(UINT64_C(0x3fecca5811030cbc));
      arg2 = vcreate_f64(UINT64_C(0x3fd6b328889e548a));
      clear_neon_saturated();
      //  Expect: "result" = ffffffffffffffff
      result = vcge_f64(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(result, 0);
      exp = UINT64_C(0xffffffffffffffff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_428() {

{
   {
      int64x2_t arg1;
      int64x2_t arg2;
      uint64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"cge\", fnname = \"vcgeq_s64\", rettype = \"uint64x2_t\", argtypes = \"[int64x2_t,int64x2_t]\", vals = [VectorVal [IntegerVal 1858720010856300543,IntegerVal 98640366370816],VectorVal [IntegerVal 9223372032559851686,IntegerVal 2147521207]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s64(vcreate_s64(UINT64_C(0x19cb80007fffffff)),
                          vcreate_s64(UINT64_C(0x000059b67fff8000)));
      arg2 = vcombine_s64(vcreate_s64(UINT64_C(0x7fffffff0000a8a6)),
                          vcreate_s64(UINT64_C(0x00000000800092b7)));
      clear_neon_saturated();
      //  Expect: "result" = ffffffffffffffff0000000000000000
      result = vcgeq_s64(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 0);
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 1);
         exp = UINT64_C(0xffffffffffffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_429() {

{
   {
      uint64x2_t arg1;
      uint64x2_t arg2;
      uint64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"cge\", fnname = \"vcgeq_u64\", rettype = \"uint64x2_t\", argtypes = \"[uint64x2_t,uint64x2_t]\", vals = [VectorVal [IntegerVal 18446512065337655296,IntegerVal 2545941162382426112],VectorVal [IntegerVal 9223231303661387775,IntegerVal 9223231297218904064]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u64(vcreate_u64(UINT64_C(0xffff2cfd57688000)),
                          vcreate_u64(UINT64_C(0x2354ffff8ad98000)));
      arg2 = vcombine_u64(vcreate_u64(UINT64_C(0x7fff8000ffffffff)),
                          vcreate_u64(UINT64_C(0x7fff7fff7fff8000)));
      clear_neon_saturated();
      //  Expect: "result" = 0000000000000000ffffffffffffffff
      result = vcgeq_u64(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 0);
         exp = UINT64_C(0xffffffffffffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 1);
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_430() {

{
   {
      float64x2_t arg1;
      float64x2_t arg2;
      uint64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"cge\", fnname = \"vcgeq_f64\", rettype = \"uint64x2_t\", argtypes = \"[float64x2_t,float64x2_t]\", vals = [VectorVal [FloatVal 0.9753480261822668,FloatVal 0.8650751068463587],VectorVal [FloatVal 0.8688812819926862,FloatVal 0.5729589109934595]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_f64(vcreate_f64(UINT64_C(0x3fef360d105578bb)),
                          vcreate_f64(UINT64_C(0x3febaeb1fd8fa462)));
      arg2 = vcombine_f64(vcreate_f64(UINT64_C(0x3febcde01e487c09)),
                          vcreate_f64(UINT64_C(0x3fe255aded1565db)));
      clear_neon_saturated();
      //  Expect: "result" = ffffffffffffffffffffffffffffffff
      result = vcgeq_f64(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 0);
         exp = UINT64_C(0xffffffffffffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 1);
         exp = UINT64_C(0xffffffffffffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_431() {

{
   {
      int64_t arg1;
      int64_t arg2;
      uint64_t result;
      char* str1 = "ReproInfo2 {semantics = \"cge\", fnname = \"vcged_s64\", rettype = \"uint64_t\", argtypes = \"[int64_t,int64_t]\", vals = [IntegerVal 9223231297218969599,IntegerVal 140737488388095], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = INT64_C(9223231297218969599);
      arg2 = INT64_C(140737488388095);
      clear_neon_saturated();
      //  Expect: "result" = ffffffffffffffff
      result = vcged_s64(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = UINT64_C(0xffffffffffffffff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_432() {

{
   {
      uint64_t arg1;
      uint64_t arg2;
      uint64_t result;
      char* str1 = "ReproInfo2 {semantics = \"cge\", fnname = \"vcged_u64\", rettype = \"uint64_t\", argtypes = \"[uint64_t,uint64_t]\", vals = [IntegerVal 4294934528,IntegerVal 9223090561878097920], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = UINT64_C(0x00000000ffff8000);
      arg2 = UINT64_C(0x7fff000000008000);
      clear_neon_saturated();
      //  Expect: "result" = 0000000000000000
      result = vcged_u64(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = 0;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_433() {

{
   {
      float32_t arg1;
      float32_t arg2;
      uint32_t result;
      char* str1 = "ReproInfo2 {semantics = \"cge\", fnname = \"vcges_f32\", rettype = \"uint32_t\", argtypes = \"[float32_t,float32_t]\", vals = [FloatVal 0.8124157786369324,FloatVal 0.2660365104675293], start_saturated = False}";
      int reported = 0;
      uint32_t got;
      uint32_t exp;
      arg1 = ((float32_t) 0.8124157786369324);
      arg2 = ((float32_t) 0.2660365104675293);
      clear_neon_saturated();
      //  Expect: "result" = ffffffff
      result = vcges_f32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = 4294967295U;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIu32 " Got: %" PRIu32 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_434() {

{
   {
      float64_t arg1;
      float64_t arg2;
      uint64_t result;
      char* str1 = "ReproInfo2 {semantics = \"cge\", fnname = \"vcged_f64\", rettype = \"uint64_t\", argtypes = \"[float64_t,float64_t]\", vals = [FloatVal 0.5920066047947112,FloatVal 0.9503528284173293], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = 0.5920066047947112;
      arg2 = 0.9503528284173293;
      clear_neon_saturated();
      //  Expect: "result" = 0000000000000000
      result = vcged_f64(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = 0;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_435() {

{
   {
      int8x8_t arg1;
      int8x8_t arg2;
      uint8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"cle\", fnname = \"vcle_s8\", rettype = \"uint8x8_t\", argtypes = \"[int8x8_t,int8x8_t]\", vals = [VectorVal [IntegerVal 0,IntegerVal 65,IntegerVal (-128),IntegerVal 0,IntegerVal (-128),IntegerVal (-1),IntegerVal (-128),IntegerVal (-1)],VectorVal [IntegerVal (-1),IntegerVal 108,IntegerVal (-128),IntegerVal (-128),IntegerVal 15,IntegerVal (-128),IntegerVal (-128),IntegerVal (-1)]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s8(UINT64_C(0xff80ff8000804100));
      arg2 = vcreate_s8(UINT64_C(0xff80800f80806cff));
      clear_neon_saturated();
      //  Expect: "result" = ffff00ff00ffff00
      result = vcle_s8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u8(result), 0);
      exp = UINT64_C(0xffff00ff00ffff00);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_436() {

{
   {
      int16x4_t arg1;
      int16x4_t arg2;
      uint16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"cle\", fnname = \"vcle_s16\", rettype = \"uint16x4_t\", argtypes = \"[int16x4_t,int16x4_t]\", vals = [VectorVal [IntegerVal 32767,IntegerVal 6277,IntegerVal (-32768),IntegerVal 32767],VectorVal [IntegerVal 32767,IntegerVal 32767,IntegerVal (-32768),IntegerVal 32767]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s16(UINT64_C(0x7fff800018857fff));
      arg2 = vcreate_s16(UINT64_C(0x7fff80007fff7fff));
      clear_neon_saturated();
      //  Expect: "result" = ffffffffffffffff
      result = vcle_s16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u16(result), 0);
      exp = UINT64_C(0xffffffffffffffff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_437() {

{
   {
      int32x2_t arg1;
      int32x2_t arg2;
      uint32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"cle\", fnname = \"vcle_s32\", rettype = \"uint32x2_t\", argtypes = \"[int32x2_t,int32x2_t]\", vals = [VectorVal [IntegerVal 2147439044,IntegerVal (-6848)],VectorVal [IntegerVal 17160,IntegerVal 32768]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s32(UINT64_C(0xffffe5407fff51c4));
      arg2 = vcreate_s32(UINT64_C(0x0000800000004308));
      clear_neon_saturated();
      //  Expect: "result" = ffffffff00000000
      result = vcle_s32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u32(result), 0);
      exp = UINT64_C(0xffffffff00000000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_438() {

{
   {
      float32x2_t arg1;
      float32x2_t arg2;
      uint32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"cle\", fnname = \"vcle_f32\", rettype = \"uint32x2_t\", argtypes = \"[float32x2_t,float32x2_t]\", vals = [VectorVal [FloatVal 0.11911267042160034,FloatVal 0.9773296117782593],VectorVal [FloatVal 0.1493215560913086,FloatVal 0.31313663721084595]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_f32(UINT64_C(0x3f7a32463df3f158));
      arg2 = vcreate_f32(UINT64_C(0x3ea053723e18e7c0));
      clear_neon_saturated();
      //  Expect: "result" = 00000000ffffffff
      result = vcle_f32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u32(result), 0);
      exp = UINT64_C(0x00000000ffffffff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_439() {

{
   {
      uint8x8_t arg1;
      uint8x8_t arg2;
      uint8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"cle\", fnname = \"vcle_u8\", rettype = \"uint8x8_t\", argtypes = \"[uint8x8_t,uint8x8_t]\", vals = [VectorVal [IntegerVal 128,IntegerVal 209,IntegerVal 255,IntegerVal 127,IntegerVal 72,IntegerVal 197,IntegerVal 128,IntegerVal 0],VectorVal [IntegerVal 127,IntegerVal 127,IntegerVal 0,IntegerVal 128,IntegerVal 92,IntegerVal 128,IntegerVal 197,IntegerVal 127]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u8(UINT64_C(0x0080c5487fffd180));
      arg2 = vcreate_u8(UINT64_C(0x7fc5805c80007f7f));
      clear_neon_saturated();
      //  Expect: "result" = ffff00ffff000000
      result = vcle_u8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u8(result), 0);
      exp = UINT64_C(0xffff00ffff000000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_440() {

{
   {
      uint16x4_t arg1;
      uint16x4_t arg2;
      uint16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"cle\", fnname = \"vcle_u16\", rettype = \"uint16x4_t\", argtypes = \"[uint16x4_t,uint16x4_t]\", vals = [VectorVal [IntegerVal 29616,IntegerVal 32768,IntegerVal 0,IntegerVal 62400],VectorVal [IntegerVal 65535,IntegerVal 32767,IntegerVal 65535,IntegerVal 65535]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u16(UINT64_C(0xf3c00000800073b0));
      arg2 = vcreate_u16(UINT64_C(0xffffffff7fffffff));
      clear_neon_saturated();
      //  Expect: "result" = ffffffff0000ffff
      result = vcle_u16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u16(result), 0);
      exp = UINT64_C(0xffffffff0000ffff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_441() {

{
   {
      uint32x2_t arg1;
      uint32x2_t arg2;
      uint32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"cle\", fnname = \"vcle_u32\", rettype = \"uint32x2_t\", argtypes = \"[uint32x2_t,uint32x2_t]\", vals = [VectorVal [IntegerVal 2147450880,IntegerVal 2147523193],VectorVal [IntegerVal 4294954796,IntegerVal 2147516416]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u32(UINT64_C(0x80009a797fff8000));
      arg2 = vcreate_u32(UINT64_C(0x80008000ffffcf2c));
      clear_neon_saturated();
      //  Expect: "result" = 00000000ffffffff
      result = vcle_u32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u32(result), 0);
      exp = UINT64_C(0x00000000ffffffff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_442() {

{
   {
      int8x16_t arg1;
      int8x16_t arg2;
      uint8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"cle\", fnname = \"vcleq_s8\", rettype = \"uint8x16_t\", argtypes = \"[int8x16_t,int8x16_t]\", vals = [VectorVal [IntegerVal (-127),IntegerVal 127,IntegerVal 25,IntegerVal (-128),IntegerVal (-128),IntegerVal (-128),IntegerVal (-128),IntegerVal 0,IntegerVal (-128),IntegerVal 127,IntegerVal 127,IntegerVal 113,IntegerVal (-1),IntegerVal 0,IntegerVal (-59),IntegerVal (-1)],VectorVal [IntegerVal 127,IntegerVal 127,IntegerVal (-109),IntegerVal 0,IntegerVal (-72),IntegerVal 127,IntegerVal (-1),IntegerVal (-1),IntegerVal 90,IntegerVal (-128),IntegerVal 127,IntegerVal 127,IntegerVal (-128),IntegerVal (-1),IntegerVal 127,IntegerVal (-1)]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s8(vcreate_s8(UINT64_C(0x0080808080197f81)),
                         vcreate_s8(UINT64_C(0xffc500ff717f7f80)));
      arg2 = vcombine_s8(vcreate_s8(UINT64_C(0xffff7fb800937f7f)),
                         vcreate_s8(UINT64_C(0xff7fff807f7f805a)));
      clear_neon_saturated();
      //  Expect: "result" = ffff0000ffff00ff00ffffffff00ffff
      result = vcleq_s8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 0);
         exp = UINT64_C(0x00ffffffff00ffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 1);
         exp = UINT64_C(0xffff0000ffff00ff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_443() {

{
   {
      int16x8_t arg1;
      int16x8_t arg2;
      uint16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"cle\", fnname = \"vcleq_s16\", rettype = \"uint16x8_t\", argtypes = \"[int16x8_t,int16x8_t]\", vals = [VectorVal [IntegerVal (-1),IntegerVal (-32768),IntegerVal 32767,IntegerVal 0,IntegerVal (-1),IntegerVal (-1),IntegerVal (-1),IntegerVal (-1)],VectorVal [IntegerVal 0,IntegerVal (-18814),IntegerVal (-1),IntegerVal (-1),IntegerVal 32767,IntegerVal 32767,IntegerVal (-32768),IntegerVal (-31875)]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s16(vcreate_s16(UINT64_C(0x00007fff8000ffff)),
                          vcreate_s16(UINT64_C(0xffffffffffffffff)));
      arg2 = vcombine_s16(vcreate_s16(UINT64_C(0xffffffffb6820000)),
                          vcreate_s16(UINT64_C(0x837d80007fff7fff)));
      clear_neon_saturated();
      //  Expect: "result" = 00000000ffffffff00000000ffffffff
      result = vcleq_s16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 0);
         exp = UINT64_C(0x00000000ffffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 1);
         exp = UINT64_C(0x00000000ffffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_444() {

{
   {
      int32x4_t arg1;
      int32x4_t arg2;
      uint32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"cle\", fnname = \"vcleq_s32\", rettype = \"uint32x4_t\", argtypes = \"[int32x4_t,int32x4_t]\", vals = [VectorVal [IntegerVal (-32769),IntegerVal 32768,IntegerVal (-32768),IntegerVal 2147450880],VectorVal [IntegerVal (-2147475798),IntegerVal 65535,IntegerVal (-2147432347),IntegerVal (-32768)]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s32(vcreate_s32(UINT64_C(0x00008000ffff7fff)),
                          vcreate_s32(UINT64_C(0x7fff8000ffff8000)));
      arg2 = vcombine_s32(vcreate_s32(UINT64_C(0x0000ffff80001eaa)),
                          vcreate_s32(UINT64_C(0xffff80008000c865)));
      clear_neon_saturated();
      //  Expect: "result" = 0000000000000000ffffffff00000000
      result = vcleq_s32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 0);
         exp = UINT64_C(0xffffffff00000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 1);
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_445() {

{
   {
      float32x4_t arg1;
      float32x4_t arg2;
      uint32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"cle\", fnname = \"vcleq_f32\", rettype = \"uint32x4_t\", argtypes = \"[float32x4_t,float32x4_t]\", vals = [VectorVal [FloatVal 0.4177969694137573,FloatVal 0.7051618695259094,FloatVal 0.13368189334869385,FloatVal 0.774517297744751],VectorVal [FloatVal 0.459153413772583,FloatVal 0.7842180132865906,FloatVal 0.9391838908195496,FloatVal 0.3144046664237976]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_f32(vcreate_f32(UINT64_C(0x3f34857d3ed5e97c)),
                          vcreate_f32(UINT64_C(0x3f4646c43e08e3e8)));
      arg2 = vcombine_f32(vcreate_f32(UINT64_C(0x3f48c2833eeb1628)),
                          vcreate_f32(UINT64_C(0x3ea0f9a63f706e5b)));
      clear_neon_saturated();
      //  Expect: "result" = 00000000ffffffffffffffffffffffff
      result = vcleq_f32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 0);
         exp = UINT64_C(0xffffffffffffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 1);
         exp = UINT64_C(0x00000000ffffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_446() {

{
   {
      uint8x16_t arg1;
      uint8x16_t arg2;
      uint8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"cle\", fnname = \"vcleq_u8\", rettype = \"uint8x16_t\", argtypes = \"[uint8x16_t,uint8x16_t]\", vals = [VectorVal [IntegerVal 0,IntegerVal 127,IntegerVal 128,IntegerVal 0,IntegerVal 127,IntegerVal 166,IntegerVal 127,IntegerVal 127,IntegerVal 6,IntegerVal 128,IntegerVal 38,IntegerVal 127,IntegerVal 153,IntegerVal 127,IntegerVal 127,IntegerVal 128],VectorVal [IntegerVal 0,IntegerVal 81,IntegerVal 0,IntegerVal 128,IntegerVal 127,IntegerVal 128,IntegerVal 255,IntegerVal 255,IntegerVal 127,IntegerVal 130,IntegerVal 127,IntegerVal 255,IntegerVal 0,IntegerVal 244,IntegerVal 0,IntegerVal 59]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u8(vcreate_u8(UINT64_C(0x7f7fa67f00807f00)),
                         vcreate_u8(UINT64_C(0x807f7f997f268006)));
      arg2 = vcombine_u8(vcreate_u8(UINT64_C(0xffff807f80005100)),
                         vcreate_u8(UINT64_C(0x3b00f400ff7f827f)));
      clear_neon_saturated();
      //  Expect: "result" = 0000ff00ffffffffffff00ffff0000ff
      result = vcleq_u8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 0);
         exp = UINT64_C(0xffff00ffff0000ff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 1);
         exp = UINT64_C(0x0000ff00ffffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_447() {

{
   {
      uint16x8_t arg1;
      uint16x8_t arg2;
      uint16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"cle\", fnname = \"vcleq_u16\", rettype = \"uint16x8_t\", argtypes = \"[uint16x8_t,uint16x8_t]\", vals = [VectorVal [IntegerVal 32767,IntegerVal 65535,IntegerVal 61669,IntegerVal 32768,IntegerVal 0,IntegerVal 32768,IntegerVal 54017,IntegerVal 39241],VectorVal [IntegerVal 397,IntegerVal 44066,IntegerVal 32768,IntegerVal 65535,IntegerVal 12171,IntegerVal 56957,IntegerVal 38871,IntegerVal 32767]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u16(vcreate_u16(UINT64_C(0x8000f0e5ffff7fff)),
                          vcreate_u16(UINT64_C(0x9949d30180000000)));
      arg2 = vcombine_u16(vcreate_u16(UINT64_C(0xffff8000ac22018d)),
                          vcreate_u16(UINT64_C(0x7fff97d7de7d2f8b)));
      clear_neon_saturated();
      //  Expect: "result" = 00000000ffffffffffff000000000000
      result = vcleq_u16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 0);
         exp = UINT64_C(0xffff000000000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 1);
         exp = UINT64_C(0x00000000ffffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_448() {

{
   {
      uint32x4_t arg1;
      uint32x4_t arg2;
      uint32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"cle\", fnname = \"vcleq_u32\", rettype = \"uint32x4_t\", argtypes = \"[uint32x4_t,uint32x4_t]\", vals = [VectorVal [IntegerVal 65535,IntegerVal 2147450880,IntegerVal 9435,IntegerVal 0],VectorVal [IntegerVal 4294967295,IntegerVal 4294967295,IntegerVal 2845999104,IntegerVal 2147450879]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u32(vcreate_u32(UINT64_C(0x7fff80000000ffff)),
                          vcreate_u32(UINT64_C(0x00000000000024db)));
      arg2 = vcombine_u32(vcreate_u32(UINT64_C(0xffffffffffffffff)),
                          vcreate_u32(UINT64_C(0x7fff7fffa9a28000)));
      clear_neon_saturated();
      //  Expect: "result" = ffffffffffffffffffffffffffffffff
      result = vcleq_u32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 0);
         exp = UINT64_C(0xffffffffffffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 1);
         exp = UINT64_C(0xffffffffffffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_449() {

{
   {
      int64x1_t arg1;
      int64x1_t arg2;
      uint64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"cle\", fnname = \"vcle_s64\", rettype = \"uint64x1_t\", argtypes = \"[int64x1_t,int64x1_t]\", vals = [VectorVal [IntegerVal 2638124217989595135],VectorVal [IntegerVal (-137784698372097)]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s64(UINT64_C(0x249c7fffb69fffff));
      arg2 = vcreate_s64(UINT64_C(0xffff82af7fff7fff));
      clear_neon_saturated();
      //  Expect: "result" = 0000000000000000
      result = vcle_s64(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(result, 0);
      exp = 0;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_450() {

{
   {
      uint64x1_t arg1;
      uint64x1_t arg2;
      uint64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"cle\", fnname = \"vcle_u64\", rettype = \"uint64x1_t\", argtypes = \"[uint64x1_t,uint64x1_t]\", vals = [VectorVal [IntegerVal 140740784776748],VectorVal [IntegerVal 9223372036854743039]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u64(UINT64_C(0x00008000c47b662c));
      arg2 = vcreate_u64(UINT64_C(0x7fffffffffff7fff));
      clear_neon_saturated();
      //  Expect: "result" = ffffffffffffffff
      result = vcle_u64(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(result, 0);
      exp = UINT64_C(0xffffffffffffffff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_451() {

{
   {
      float64x1_t arg1;
      float64x1_t arg2;
      uint64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"cle\", fnname = \"vcle_f64\", rettype = \"uint64x1_t\", argtypes = \"[float64x1_t,float64x1_t]\", vals = [VectorVal [FloatVal 0.1456712534569793],VectorVal [FloatVal 0.7979027675106829]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_f64(UINT64_C(0x3fc2a55b0ac853a8));
      arg2 = vcreate_f64(UINT64_C(0x3fe9886b627b14ae));
      clear_neon_saturated();
      //  Expect: "result" = ffffffffffffffff
      result = vcle_f64(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(result, 0);
      exp = UINT64_C(0xffffffffffffffff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_452() {

{
   {
      int64x2_t arg1;
      int64x2_t arg2;
      uint64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"cle\", fnname = \"vcleq_s64\", rettype = \"uint64x2_t\", argtypes = \"[int64x2_t,int64x2_t]\", vals = [VectorVal [IntegerVal (-4294967296),IntegerVal 281470681794309],VectorVal [IntegerVal 9223231295071453184,IntegerVal (-9223372034707324929)]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s64(vcreate_s64(UINT64_C(0xffffffff00000000)),
                          vcreate_s64(UINT64_C(0x0000ffff0000c705)));
      arg2 = vcombine_s64(vcreate_s64(UINT64_C(0x7fff7fff00000000)),
                          vcreate_s64(UINT64_C(0x800000007fff7fff)));
      clear_neon_saturated();
      //  Expect: "result" = 0000000000000000ffffffffffffffff
      result = vcleq_s64(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 0);
         exp = UINT64_C(0xffffffffffffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 1);
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_453() {

{
   {
      uint64x2_t arg1;
      uint64x2_t arg2;
      uint64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"cle\", fnname = \"vcleq_u64\", rettype = \"uint64x2_t\", argtypes = \"[uint64x2_t,uint64x2_t]\", vals = [VectorVal [IntegerVal 18446603340516158844,IntegerVal 639172607],VectorVal [IntegerVal 18446603340516130815,IntegerVal 2541416513536]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u64(vcreate_u64(UINT64_C(0xffff8000ffffed7c)),
                          vcreate_u64(UINT64_C(0x000000002618ffff)));
      arg2 = vcombine_u64(vcreate_u64(UINT64_C(0xffff8000ffff7fff)),
                          vcreate_u64(UINT64_C(0x0000024fb83a8000)));
      clear_neon_saturated();
      //  Expect: "result" = ffffffffffffffff0000000000000000
      result = vcleq_u64(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 0);
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 1);
         exp = UINT64_C(0xffffffffffffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_454() {

{
   {
      float64x2_t arg1;
      float64x2_t arg2;
      uint64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"cle\", fnname = \"vcleq_f64\", rettype = \"uint64x2_t\", argtypes = \"[float64x2_t,float64x2_t]\", vals = [VectorVal [FloatVal 0.6620606893815918,FloatVal 0.20173022309807231],VectorVal [FloatVal 0.23255616767045562,FloatVal 0.6383186186670216]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_f64(vcreate_f64(UINT64_C(0x3fe52f99e61b8e8d)),
                          vcreate_f64(UINT64_C(0x3fc9d24bc36916ac)));
      arg2 = vcombine_f64(vcreate_f64(UINT64_C(0x3fcdc46687505874)),
                          vcreate_f64(UINT64_C(0x3fe46d1b2af349c0)));
      clear_neon_saturated();
      //  Expect: "result" = ffffffffffffffff0000000000000000
      result = vcleq_f64(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 0);
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 1);
         exp = UINT64_C(0xffffffffffffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_455() {

{
   {
      int64_t arg1;
      int64_t arg2;
      uint64_t result;
      char* str1 = "ReproInfo2 {semantics = \"cle\", fnname = \"vcled_s64\", rettype = \"uint64_t\", argtypes = \"[int64_t,int64_t]\", vals = [IntegerVal 140741783289855,IntegerVal (-9223231297218914104)], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = INT64_C(140741783289855);
      arg2 = INT64_C(-9223231297218914104);
      clear_neon_saturated();
      //  Expect: "result" = 0000000000000000
      result = vcled_s64(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = 0;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_456() {

{
   {
      uint64_t arg1;
      uint64_t arg2;
      uint64_t result;
      char* str1 = "ReproInfo2 {semantics = \"cle\", fnname = \"vcled_u64\", rettype = \"uint64_t\", argtypes = \"[uint64_t,uint64_t]\", vals = [IntegerVal 9223372034321874944,IntegerVal 8995658782893015039], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = UINT64_C(0x7fffffff69070000);
      arg2 = UINT64_C(0x7cd7000082f5ffff);
      clear_neon_saturated();
      //  Expect: "result" = 0000000000000000
      result = vcled_u64(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = 0;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_457() {

{
   {
      float32_t arg1;
      float32_t arg2;
      uint32_t result;
      char* str1 = "ReproInfo2 {semantics = \"cle\", fnname = \"vcles_f32\", rettype = \"uint32_t\", argtypes = \"[float32_t,float32_t]\", vals = [FloatVal 0.36730051040649414,FloatVal 0.4961974024772644], start_saturated = False}";
      int reported = 0;
      uint32_t got;
      uint32_t exp;
      arg1 = ((float32_t) 0.36730051040649414);
      arg2 = ((float32_t) 0.4961974024772644);
      clear_neon_saturated();
      //  Expect: "result" = ffffffff
      result = vcles_f32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = 4294967295U;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIu32 " Got: %" PRIu32 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_458() {

{
   {
      float64_t arg1;
      float64_t arg2;
      uint64_t result;
      char* str1 = "ReproInfo2 {semantics = \"cle\", fnname = \"vcled_f64\", rettype = \"uint64_t\", argtypes = \"[float64_t,float64_t]\", vals = [FloatVal 0.4615627557681746,FloatVal 0.2548462912759485], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = 0.4615627557681746;
      arg2 = 0.2548462912759485;
      clear_neon_saturated();
      //  Expect: "result" = 0000000000000000
      result = vcled_f64(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = 0;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_459() {

{
   {
      int8x8_t arg1;
      int8x8_t arg2;
      uint8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"cgt\", fnname = \"vcgt_s8\", rettype = \"uint8x8_t\", argtypes = \"[int8x8_t,int8x8_t]\", vals = [VectorVal [IntegerVal (-60),IntegerVal 0,IntegerVal (-128),IntegerVal (-1),IntegerVal (-1),IntegerVal 127,IntegerVal 127,IntegerVal (-1)],VectorVal [IntegerVal 127,IntegerVal 0,IntegerVal 127,IntegerVal 127,IntegerVal (-86),IntegerVal 127,IntegerVal (-122),IntegerVal (-1)]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s8(UINT64_C(0xff7f7fffff8000c4));
      arg2 = vcreate_s8(UINT64_C(0xff867faa7f7f007f));
      clear_neon_saturated();
      //  Expect: "result" = 00ff00ff00000000
      result = vcgt_s8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u8(result), 0);
      exp = UINT64_C(0x00ff00ff00000000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_460() {

{
   {
      int16x4_t arg1;
      int16x4_t arg2;
      uint16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"cgt\", fnname = \"vcgt_s16\", rettype = \"uint16x4_t\", argtypes = \"[int16x4_t,int16x4_t]\", vals = [VectorVal [IntegerVal (-32768),IntegerVal (-32768),IntegerVal 32767,IntegerVal 11244],VectorVal [IntegerVal 32767,IntegerVal (-32768),IntegerVal 0,IntegerVal 0]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s16(UINT64_C(0x2bec7fff80008000));
      arg2 = vcreate_s16(UINT64_C(0x0000000080007fff));
      clear_neon_saturated();
      //  Expect: "result" = ffffffff00000000
      result = vcgt_s16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u16(result), 0);
      exp = UINT64_C(0xffffffff00000000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_461() {

{
   {
      int32x2_t arg1;
      int32x2_t arg2;
      uint32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"cgt\", fnname = \"vcgt_s32\", rettype = \"uint32x2_t\", argtypes = \"[int32x2_t,int32x2_t]\", vals = [VectorVal [IntegerVal (-2147418113),IntegerVal (-2147483648)],VectorVal [IntegerVal (-32768),IntegerVal (-65536)]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s32(UINT64_C(0x800000008000ffff));
      arg2 = vcreate_s32(UINT64_C(0xffff0000ffff8000));
      clear_neon_saturated();
      //  Expect: "result" = 0000000000000000
      result = vcgt_s32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u32(result), 0);
      exp = 0;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_462() {

{
   {
      float32x2_t arg1;
      float32x2_t arg2;
      uint32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"cgt\", fnname = \"vcgt_f32\", rettype = \"uint32x2_t\", argtypes = \"[float32x2_t,float32x2_t]\", vals = [VectorVal [FloatVal 0.7434440851211548,FloatVal 0.2963656187057495],VectorVal [FloatVal 0.4449610710144043,FloatVal 3.983408212661743e-2]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_f32(UINT64_C(0x3e97bd3c3f3e525a));
      arg2 = vcreate_f32(UINT64_C(0x3d2329103ee3d1f0));
      clear_neon_saturated();
      //  Expect: "result" = ffffffffffffffff
      result = vcgt_f32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u32(result), 0);
      exp = UINT64_C(0xffffffffffffffff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_463() {

{
   {
      uint8x8_t arg1;
      uint8x8_t arg2;
      uint8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"cgt\", fnname = \"vcgt_u8\", rettype = \"uint8x8_t\", argtypes = \"[uint8x8_t,uint8x8_t]\", vals = [VectorVal [IntegerVal 0,IntegerVal 127,IntegerVal 0,IntegerVal 175,IntegerVal 127,IntegerVal 255,IntegerVal 0,IntegerVal 127],VectorVal [IntegerVal 255,IntegerVal 255,IntegerVal 134,IntegerVal 0,IntegerVal 0,IntegerVal 118,IntegerVal 128,IntegerVal 43]], start_saturated = True}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u8(UINT64_C(0x7f00ff7faf007f00));
      arg2 = vcreate_u8(UINT64_C(0x2b8076000086ffff));
      set_neon_saturated();
      //  Expect: "result" = ff00ffffff000000
      result = vcgt_u8(arg1, arg2);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u8(result), 0);
      exp = UINT64_C(0xff00ffffff000000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_464() {

{
   {
      uint16x4_t arg1;
      uint16x4_t arg2;
      uint16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"cgt\", fnname = \"vcgt_u16\", rettype = \"uint16x4_t\", argtypes = \"[uint16x4_t,uint16x4_t]\", vals = [VectorVal [IntegerVal 0,IntegerVal 65535,IntegerVal 6336,IntegerVal 65535],VectorVal [IntegerVal 32767,IntegerVal 0,IntegerVal 32768,IntegerVal 32768]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u16(UINT64_C(0xffff18c0ffff0000));
      arg2 = vcreate_u16(UINT64_C(0x8000800000007fff));
      clear_neon_saturated();
      //  Expect: "result" = ffff0000ffff0000
      result = vcgt_u16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u16(result), 0);
      exp = UINT64_C(0xffff0000ffff0000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_465() {

{
   {
      uint32x2_t arg1;
      uint32x2_t arg2;
      uint32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"cgt\", fnname = \"vcgt_u32\", rettype = \"uint32x2_t\", argtypes = \"[uint32x2_t,uint32x2_t]\", vals = [VectorVal [IntegerVal 2147418112,IntegerVal 2147450880],VectorVal [IntegerVal 2147549183,IntegerVal 4294967295]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u32(UINT64_C(0x7fff80007fff0000));
      arg2 = vcreate_u32(UINT64_C(0xffffffff8000ffff));
      clear_neon_saturated();
      //  Expect: "result" = 0000000000000000
      result = vcgt_u32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u32(result), 0);
      exp = 0;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_466() {

{
   {
      int8x16_t arg1;
      int8x16_t arg2;
      uint8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"cgt\", fnname = \"vcgtq_s8\", rettype = \"uint8x16_t\", argtypes = \"[int8x16_t,int8x16_t]\", vals = [VectorVal [IntegerVal 0,IntegerVal 127,IntegerVal 0,IntegerVal 18,IntegerVal (-1),IntegerVal (-1),IntegerVal 0,IntegerVal (-128),IntegerVal (-128),IntegerVal 127,IntegerVal 0,IntegerVal 0,IntegerVal (-128),IntegerVal 127,IntegerVal (-1),IntegerVal (-128)],VectorVal [IntegerVal 0,IntegerVal (-128),IntegerVal (-114),IntegerVal 59,IntegerVal 127,IntegerVal (-128),IntegerVal (-128),IntegerVal 0,IntegerVal (-1),IntegerVal 0,IntegerVal 0,IntegerVal (-128),IntegerVal (-128),IntegerVal 0,IntegerVal (-128),IntegerVal (-75)]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s8(vcreate_s8(UINT64_C(0x8000ffff12007f00)),
                         vcreate_s8(UINT64_C(0x80ff7f8000007f80)));
      arg2 = vcombine_s8(vcreate_s8(UINT64_C(0x0080807f3b8e8000)),
                         vcreate_s8(UINT64_C(0xb5800080800000ff)));
      clear_neon_saturated();
      //  Expect: "result" = 00ffff00ff00ff0000ffff0000ffff00
      result = vcgtq_s8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 0);
         exp = UINT64_C(0x00ffff0000ffff00);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 1);
         exp = UINT64_C(0x00ffff00ff00ff00);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_467() {

{
   {
      int16x8_t arg1;
      int16x8_t arg2;
      uint16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"cgt\", fnname = \"vcgtq_s16\", rettype = \"uint16x8_t\", argtypes = \"[int16x8_t,int16x8_t]\", vals = [VectorVal [IntegerVal 32767,IntegerVal 0,IntegerVal 0,IntegerVal (-1),IntegerVal (-1),IntegerVal 1874,IntegerVal 0,IntegerVal 0],VectorVal [IntegerVal 0,IntegerVal (-1),IntegerVal 32767,IntegerVal (-1),IntegerVal (-1),IntegerVal 32767,IntegerVal (-32768),IntegerVal 32767]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s16(vcreate_s16(UINT64_C(0xffff000000007fff)),
                          vcreate_s16(UINT64_C(0x000000000752ffff)));
      arg2 = vcombine_s16(vcreate_s16(UINT64_C(0xffff7fffffff0000)),
                          vcreate_s16(UINT64_C(0x7fff80007fffffff)));
      clear_neon_saturated();
      //  Expect: "result" = 0000ffff0000000000000000ffffffff
      result = vcgtq_s16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 0);
         exp = UINT64_C(0x00000000ffffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 1);
         exp = UINT64_C(0x0000ffff00000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_468() {

{
   {
      int32x4_t arg1;
      int32x4_t arg2;
      uint32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"cgt\", fnname = \"vcgtq_s32\", rettype = \"uint32x4_t\", argtypes = \"[int32x4_t,int32x4_t]\", vals = [VectorVal [IntegerVal (-20220),IntegerVal (-1109721725),IntegerVal 65535,IntegerVal 65535],VectorVal [IntegerVal 32767,IntegerVal 1541636096,IntegerVal 2147483647,IntegerVal (-2147418113)]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s32(vcreate_s32(UINT64_C(0xbddafd83ffffb104)),
                          vcreate_s32(UINT64_C(0x0000ffff0000ffff)));
      arg2 = vcombine_s32(vcreate_s32(UINT64_C(0x5be3800000007fff)),
                          vcreate_s32(UINT64_C(0x8000ffff7fffffff)));
      clear_neon_saturated();
      //  Expect: "result" = ffffffff000000000000000000000000
      result = vcgtq_s32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 0);
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 1);
         exp = UINT64_C(0xffffffff00000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_469() {

{
   {
      float32x4_t arg1;
      float32x4_t arg2;
      uint32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"cgt\", fnname = \"vcgtq_f32\", rettype = \"uint32x4_t\", argtypes = \"[float32x4_t,float32x4_t]\", vals = [VectorVal [FloatVal 1.7205119132995605e-2,FloatVal 0.8866116404533386,FloatVal 0.29345226287841797,FloatVal 0.8003382086753845],VectorVal [FloatVal 6.560403108596802e-2,FloatVal 0.5092384815216064,FloatVal 0.16813433170318604,FloatVal 0.15904802083969116]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_f32(vcreate_f32(UINT64_C(0x3f62f8fb3c8cf1c0)),
                          vcreate_f32(UINT64_C(0x3f4ce2f73e963f60)));
      arg2 = vcombine_f32(vcreate_f32(UINT64_C(0x3f025d743d865b68)),
                          vcreate_f32(UINT64_C(0x3e22dd7c3e2c2b68)));
      clear_neon_saturated();
      //  Expect: "result" = ffffffffffffffffffffffff00000000
      result = vcgtq_f32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 0);
         exp = UINT64_C(0xffffffff00000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 1);
         exp = UINT64_C(0xffffffffffffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_470() {

{
   {
      uint8x16_t arg1;
      uint8x16_t arg2;
      uint8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"cgt\", fnname = \"vcgtq_u8\", rettype = \"uint8x16_t\", argtypes = \"[uint8x16_t,uint8x16_t]\", vals = [VectorVal [IntegerVal 127,IntegerVal 255,IntegerVal 0,IntegerVal 0,IntegerVal 162,IntegerVal 45,IntegerVal 128,IntegerVal 0,IntegerVal 53,IntegerVal 0,IntegerVal 127,IntegerVal 127,IntegerVal 127,IntegerVal 127,IntegerVal 255,IntegerVal 0],VectorVal [IntegerVal 0,IntegerVal 127,IntegerVal 255,IntegerVal 255,IntegerVal 0,IntegerVal 0,IntegerVal 255,IntegerVal 128,IntegerVal 255,IntegerVal 128,IntegerVal 255,IntegerVal 255,IntegerVal 128,IntegerVal 127,IntegerVal 127,IntegerVal 255]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u8(vcreate_u8(UINT64_C(0x00802da20000ff7f)),
                         vcreate_u8(UINT64_C(0x00ff7f7f7f7f0035)));
      arg2 = vcombine_u8(vcreate_u8(UINT64_C(0x80ff0000ffff7f00)),
                         vcreate_u8(UINT64_C(0xff7f7f80ffff80ff)));
      clear_neon_saturated();
      //  Expect: "result" = 00ff0000000000000000ffff0000ffff
      result = vcgtq_u8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 0);
         exp = UINT64_C(0x0000ffff0000ffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 1);
         exp = UINT64_C(0x00ff000000000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_471() {

{
   {
      uint16x8_t arg1;
      uint16x8_t arg2;
      uint16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"cgt\", fnname = \"vcgtq_u16\", rettype = \"uint16x8_t\", argtypes = \"[uint16x8_t,uint16x8_t]\", vals = [VectorVal [IntegerVal 65535,IntegerVal 32767,IntegerVal 46697,IntegerVal 32606,IntegerVal 0,IntegerVal 32768,IntegerVal 36854,IntegerVal 65535],VectorVal [IntegerVal 0,IntegerVal 9011,IntegerVal 32768,IntegerVal 32768,IntegerVal 0,IntegerVal 65535,IntegerVal 46776,IntegerVal 0]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u16(vcreate_u16(UINT64_C(0x7f5eb6697fffffff)),
                          vcreate_u16(UINT64_C(0xffff8ff680000000)));
      arg2 = vcombine_u16(vcreate_u16(UINT64_C(0x8000800023330000)),
                          vcreate_u16(UINT64_C(0x0000b6b8ffff0000)));
      clear_neon_saturated();
      //  Expect: "result" = ffff0000000000000000ffffffffffff
      result = vcgtq_u16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 0);
         exp = UINT64_C(0x0000ffffffffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 1);
         exp = UINT64_C(0xffff000000000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_472() {

{
   {
      uint32x4_t arg1;
      uint32x4_t arg2;
      uint32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"cgt\", fnname = \"vcgtq_u32\", rettype = \"uint32x4_t\", argtypes = \"[uint32x4_t,uint32x4_t]\", vals = [VectorVal [IntegerVal 32768,IntegerVal 4294934528,IntegerVal 2147549183,IntegerVal 32768],VectorVal [IntegerVal 0,IntegerVal 65535,IntegerVal 4294934527,IntegerVal 0]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u32(vcreate_u32(UINT64_C(0xffff800000008000)),
                          vcreate_u32(UINT64_C(0x000080008000ffff)));
      arg2 = vcombine_u32(vcreate_u32(UINT64_C(0x0000ffff00000000)),
                          vcreate_u32(UINT64_C(0x00000000ffff7fff)));
      clear_neon_saturated();
      //  Expect: "result" = ffffffff00000000ffffffffffffffff
      result = vcgtq_u32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 0);
         exp = UINT64_C(0xffffffffffffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 1);
         exp = UINT64_C(0xffffffff00000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_473() {

{
   {
      int64x1_t arg1;
      int64x1_t arg2;
      uint64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"cgt\", fnname = \"vcgt_s64\", rettype = \"uint64x1_t\", argtypes = \"[int64x1_t,int64x1_t]\", vals = [VectorVal [IntegerVal (-140735340904449)],VectorVal [IntegerVal (-140733193420800)]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s64(UINT64_C(0xffff80007fff7fff));
      arg2 = vcreate_s64(UINT64_C(0xffff8000ffff8000));
      clear_neon_saturated();
      //  Expect: "result" = 0000000000000000
      result = vcgt_s64(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(result, 0);
      exp = 0;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_474() {

{
   {
      uint64x1_t arg1;
      uint64x1_t arg2;
      uint64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"cgt\", fnname = \"vcgt_u64\", rettype = \"uint64x1_t\", argtypes = \"[uint64x1_t,uint64x1_t]\", vals = [VectorVal [IntegerVal 14500634390373105663],VectorVal [IntegerVal 9223620391191202737]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u64(UINT64_C(0xc93c9a2680007fff));
      arg2 = vcreate_u64(UINT64_C(0x8000e1e080004bb1));
      clear_neon_saturated();
      //  Expect: "result" = ffffffffffffffff
      result = vcgt_u64(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(result, 0);
      exp = UINT64_C(0xffffffffffffffff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_475() {

{
   {
      float64x1_t arg1;
      float64x1_t arg2;
      uint64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"cgt\", fnname = \"vcgt_f64\", rettype = \"uint64x1_t\", argtypes = \"[float64x1_t,float64x1_t]\", vals = [VectorVal [FloatVal 0.6320469607869017],VectorVal [FloatVal 0.38537476109418867]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_f64(UINT64_C(0x3fe439ba8c43b5c2));
      arg2 = vcreate_f64(UINT64_C(0x3fd8a9fae6e69d58));
      clear_neon_saturated();
      //  Expect: "result" = ffffffffffffffff
      result = vcgt_f64(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(result, 0);
      exp = UINT64_C(0xffffffffffffffff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_476() {

{
   {
      int64x2_t arg1;
      int64x2_t arg2;
      uint64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"cgt\", fnname = \"vcgtq_s64\", rettype = \"uint64x2_t\", argtypes = \"[int64x2_t,int64x2_t]\", vals = [VectorVal [IntegerVal 9223231295071453184,IntegerVal 9223372036854743039],VectorVal [IntegerVal 281474976677887,IntegerVal 4294967295]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s64(vcreate_s64(UINT64_C(0x7fff7fff00000000)),
                          vcreate_s64(UINT64_C(0x7fffffffffff7fff)));
      arg2 = vcombine_s64(vcreate_s64(UINT64_C(0x0000ffffffff7fff)),
                          vcreate_s64(UINT64_C(0x00000000ffffffff)));
      clear_neon_saturated();
      //  Expect: "result" = ffffffffffffffffffffffffffffffff
      result = vcgtq_s64(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 0);
         exp = UINT64_C(0xffffffffffffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 1);
         exp = UINT64_C(0xffffffffffffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_477() {

{
   {
      uint64x2_t arg1;
      uint64x2_t arg2;
      uint64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"cgt\", fnname = \"vcgtq_u64\", rettype = \"uint64x2_t\", argtypes = \"[uint64x2_t,uint64x2_t]\", vals = [VectorVal [IntegerVal 18446603336221196288,IntegerVal 32768],VectorVal [IntegerVal 9223512776310095872,IntegerVal 8012185212068757504]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u64(vcreate_u64(UINT64_C(0xffff800000000000)),
                          vcreate_u64(UINT64_C(0x0000000000008000)));
      arg2 = vcombine_u64(vcreate_u64(UINT64_C(0x80008000753d8000)),
                          vcreate_u64(UINT64_C(0x6f30ffffffff0000)));
      clear_neon_saturated();
      //  Expect: "result" = 0000000000000000ffffffffffffffff
      result = vcgtq_u64(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 0);
         exp = UINT64_C(0xffffffffffffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 1);
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_478() {

{
   {
      float64x2_t arg1;
      float64x2_t arg2;
      uint64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"cgt\", fnname = \"vcgtq_f64\", rettype = \"uint64x2_t\", argtypes = \"[float64x2_t,float64x2_t]\", vals = [VectorVal [FloatVal 9.367823300401235e-2,FloatVal 0.4725559583068679],VectorVal [FloatVal 0.29986310324146526,FloatVal 0.9933233815736151]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_f64(vcreate_f64(UINT64_C(0x3fb7fb4bf3196bc8)),
                          vcreate_f64(UINT64_C(0x3fde3e5b589d4ed8)));
      arg2 = vcombine_f64(vcreate_f64(UINT64_C(0x3fd330f5036cbf1e)),
                          vcreate_f64(UINT64_C(0x3fefc94e1dc6beec)));
      clear_neon_saturated();
      //  Expect: "result" = 00000000000000000000000000000000
      result = vcgtq_f64(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 0);
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 1);
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_479() {

{
   {
      int64_t arg1;
      int64_t arg2;
      uint64_t result;
      char* str1 = "ReproInfo2 {semantics = \"cgt\", fnname = \"vcgtd_s64\", rettype = \"uint64_t\", argtypes = \"[int64_t,int64_t]\", vals = [IntegerVal 2147489170,IntegerVal 281470681776128], start_saturated = True}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = INT64_C(2147489170);
      arg2 = INT64_C(281470681776128);
      set_neon_saturated();
      //  Expect: "result" = 0000000000000000
      result = vcgtd_s64(arg1, arg2);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      got = result;
      exp = 0;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_480() {

{
   {
      uint64_t arg1;
      uint64_t arg2;
      uint64_t result;
      char* str1 = "ReproInfo2 {semantics = \"cgt\", fnname = \"vcgtd_u64\", rettype = \"uint64_t\", argtypes = \"[uint64_t,uint64_t]\", vals = [IntegerVal 9223471362268495872,IntegerVal 9223090564025548799], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = UINT64_C(0x80005a5600008000);
      arg2 = UINT64_C(0x7fff00007fffffff);
      clear_neon_saturated();
      //  Expect: "result" = ffffffffffffffff
      result = vcgtd_u64(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = UINT64_C(0xffffffffffffffff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_481() {

{
   {
      float32_t arg1;
      float32_t arg2;
      uint32_t result;
      char* str1 = "ReproInfo2 {semantics = \"cgt\", fnname = \"vcgts_f32\", rettype = \"uint32_t\", argtypes = \"[float32_t,float32_t]\", vals = [FloatVal 0.25199735164642334,FloatVal 0.8890627026557922], start_saturated = False}";
      int reported = 0;
      uint32_t got;
      uint32_t exp;
      arg1 = ((float32_t) 0.25199735164642334);
      arg2 = ((float32_t) 0.8890627026557922);
      clear_neon_saturated();
      //  Expect: "result" = 00000000
      result = vcgts_f32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = 0;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIu32 " Got: %" PRIu32 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_482() {

{
   {
      float64_t arg1;
      float64_t arg2;
      uint64_t result;
      char* str1 = "ReproInfo2 {semantics = \"cgt\", fnname = \"vcgtd_f64\", rettype = \"uint64_t\", argtypes = \"[float64_t,float64_t]\", vals = [FloatVal 0.6069491456622899,FloatVal 0.972212956284481], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = 0.6069491456622899;
      arg2 = 0.972212956284481;
      clear_neon_saturated();
      //  Expect: "result" = 0000000000000000
      result = vcgtd_f64(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = 0;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_483() {

{
   {
      int8x8_t arg1;
      int8x8_t arg2;
      uint8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"clt\", fnname = \"vclt_s8\", rettype = \"uint8x8_t\", argtypes = \"[int8x8_t,int8x8_t]\", vals = [VectorVal [IntegerVal 0,IntegerVal 127,IntegerVal (-128),IntegerVal (-122),IntegerVal (-1),IntegerVal (-1),IntegerVal (-1),IntegerVal 0],VectorVal [IntegerVal (-1),IntegerVal 127,IntegerVal (-1),IntegerVal (-1),IntegerVal (-1),IntegerVal (-128),IntegerVal 127,IntegerVal (-128)]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s8(UINT64_C(0x00ffffff86807f00));
      arg2 = vcreate_s8(UINT64_C(0x807f80ffffff7fff));
      clear_neon_saturated();
      //  Expect: "result" = 00ff0000ffff0000
      result = vclt_s8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u8(result), 0);
      exp = UINT64_C(0x00ff0000ffff0000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_484() {

{
   {
      int16x4_t arg1;
      int16x4_t arg2;
      uint16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"clt\", fnname = \"vclt_s16\", rettype = \"uint16x4_t\", argtypes = \"[int16x4_t,int16x4_t]\", vals = [VectorVal [IntegerVal 0,IntegerVal 32767,IntegerVal 0,IntegerVal 0],VectorVal [IntegerVal (-32768),IntegerVal (-9536),IntegerVal (-32768),IntegerVal (-32768)]], start_saturated = True}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s16(UINT64_C(0x000000007fff0000));
      arg2 = vcreate_s16(UINT64_C(0x80008000dac08000));
      set_neon_saturated();
      //  Expect: "result" = 0000000000000000
      result = vclt_s16(arg1, arg2);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u16(result), 0);
      exp = 0;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_485() {

{
   {
      int32x2_t arg1;
      int32x2_t arg2;
      uint32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"clt\", fnname = \"vclt_s32\", rettype = \"uint32x2_t\", argtypes = \"[int32x2_t,int32x2_t]\", vals = [VectorVal [IntegerVal 2147418112,IntegerVal 65535],VectorVal [IntegerVal 2147450880,IntegerVal 869335039]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s32(UINT64_C(0x0000ffff7fff0000));
      arg2 = vcreate_s32(UINT64_C(0x33d0ffff7fff8000));
      clear_neon_saturated();
      //  Expect: "result" = ffffffffffffffff
      result = vclt_s32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u32(result), 0);
      exp = UINT64_C(0xffffffffffffffff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_486() {

{
   {
      float32x2_t arg1;
      float32x2_t arg2;
      uint32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"clt\", fnname = \"vclt_f32\", rettype = \"uint32x2_t\", argtypes = \"[float32x2_t,float32x2_t]\", vals = [VectorVal [FloatVal 0.5922384858131409,FloatVal 0.5808623433113098],VectorVal [FloatVal 0.8279045224189758,FloatVal 0.9200665354728699]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_f32(UINT64_C(0x3f14b3653f179cf1));
      arg2 = vcreate_f32(UINT64_C(0x3f6b897b3f53f18d));
      clear_neon_saturated();
      //  Expect: "result" = ffffffffffffffff
      result = vclt_f32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u32(result), 0);
      exp = UINT64_C(0xffffffffffffffff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_487() {

{
   {
      uint8x8_t arg1;
      uint8x8_t arg2;
      uint8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"clt\", fnname = \"vclt_u8\", rettype = \"uint8x8_t\", argtypes = \"[uint8x8_t,uint8x8_t]\", vals = [VectorVal [IntegerVal 128,IntegerVal 215,IntegerVal 136,IntegerVal 255,IntegerVal 0,IntegerVal 0,IntegerVal 128,IntegerVal 127],VectorVal [IntegerVal 255,IntegerVal 127,IntegerVal 127,IntegerVal 127,IntegerVal 0,IntegerVal 0,IntegerVal 0,IntegerVal 0]], start_saturated = True}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u8(UINT64_C(0x7f800000ff88d780));
      arg2 = vcreate_u8(UINT64_C(0x000000007f7f7fff));
      set_neon_saturated();
      //  Expect: "result" = 00000000000000ff
      result = vclt_u8(arg1, arg2);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u8(result), 0);
      exp = UINT64_C(0x00000000000000ff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_488() {

{
   {
      uint16x4_t arg1;
      uint16x4_t arg2;
      uint16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"clt\", fnname = \"vclt_u16\", rettype = \"uint16x4_t\", argtypes = \"[uint16x4_t,uint16x4_t]\", vals = [VectorVal [IntegerVal 32768,IntegerVal 32768,IntegerVal 65535,IntegerVal 13147],VectorVal [IntegerVal 32768,IntegerVal 65535,IntegerVal 32767,IntegerVal 2808]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u16(UINT64_C(0x335bffff80008000));
      arg2 = vcreate_u16(UINT64_C(0x0af87fffffff8000));
      clear_neon_saturated();
      //  Expect: "result" = 00000000ffff0000
      result = vclt_u16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u16(result), 0);
      exp = UINT64_C(0x00000000ffff0000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_489() {

{
   {
      uint32x2_t arg1;
      uint32x2_t arg2;
      uint32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"clt\", fnname = \"vclt_u32\", rettype = \"uint32x2_t\", argtypes = \"[uint32x2_t,uint32x2_t]\", vals = [VectorVal [IntegerVal 516358144,IntegerVal 2147549183],VectorVal [IntegerVal 2147450879,IntegerVal 3261156552]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u32(UINT64_C(0x8000ffff1ec70000));
      arg2 = vcreate_u32(UINT64_C(0xc2614cc87fff7fff));
      clear_neon_saturated();
      //  Expect: "result" = ffffffffffffffff
      result = vclt_u32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u32(result), 0);
      exp = UINT64_C(0xffffffffffffffff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_490() {

{
   {
      int8x16_t arg1;
      int8x16_t arg2;
      uint8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"clt\", fnname = \"vcltq_s8\", rettype = \"uint8x16_t\", argtypes = \"[int8x16_t,int8x16_t]\", vals = [VectorVal [IntegerVal 0,IntegerVal (-128),IntegerVal 0,IntegerVal 127,IntegerVal (-128),IntegerVal (-1),IntegerVal 127,IntegerVal 112,IntegerVal 0,IntegerVal 0,IntegerVal (-66),IntegerVal 0,IntegerVal (-128),IntegerVal 0,IntegerVal 91,IntegerVal (-1)],VectorVal [IntegerVal 127,IntegerVal (-128),IntegerVal 0,IntegerVal 72,IntegerVal (-128),IntegerVal (-1),IntegerVal 0,IntegerVal (-115),IntegerVal (-128),IntegerVal 127,IntegerVal 66,IntegerVal (-128),IntegerVal (-15),IntegerVal (-128),IntegerVal (-1),IntegerVal 59]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s8(vcreate_s8(UINT64_C(0x707fff807f008000)),
                         vcreate_s8(UINT64_C(0xff5b008000be0000)));
      arg2 = vcombine_s8(vcreate_s8(UINT64_C(0x8d00ff804800807f)),
                         vcreate_s8(UINT64_C(0x3bff80f180427f80)));
      clear_neon_saturated();
      //  Expect: "result" = ff0000ff00ffff0000000000000000ff
      result = vcltq_s8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 0);
         exp = UINT64_C(0x00000000000000ff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 1);
         exp = UINT64_C(0xff0000ff00ffff00);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_491() {

{
   {
      int16x8_t arg1;
      int16x8_t arg2;
      uint16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"clt\", fnname = \"vcltq_s16\", rettype = \"uint16x8_t\", argtypes = \"[int16x8_t,int16x8_t]\", vals = [VectorVal [IntegerVal 0,IntegerVal (-32768),IntegerVal 7151,IntegerVal 25357,IntegerVal (-1),IntegerVal 0,IntegerVal 32767,IntegerVal 17221],VectorVal [IntegerVal 32767,IntegerVal (-1),IntegerVal 0,IntegerVal (-1),IntegerVal 32767,IntegerVal (-1),IntegerVal (-1),IntegerVal (-1)]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s16(vcreate_s16(UINT64_C(0x630d1bef80000000)),
                          vcreate_s16(UINT64_C(0x43457fff0000ffff)));
      arg2 = vcombine_s16(vcreate_s16(UINT64_C(0xffff0000ffff7fff)),
                          vcreate_s16(UINT64_C(0xffffffffffff7fff)));
      clear_neon_saturated();
      //  Expect: "result" = 000000000000ffff00000000ffffffff
      result = vcltq_s16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 0);
         exp = UINT64_C(0x00000000ffffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 1);
         exp = UINT64_C(0x000000000000ffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_492() {

{
   {
      int32x4_t arg1;
      int32x4_t arg2;
      uint32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"clt\", fnname = \"vcltq_s32\", rettype = \"uint32x4_t\", argtypes = \"[int32x4_t,int32x4_t]\", vals = [VectorVal [IntegerVal 717455360,IntegerVal 2147483647,IntegerVal (-1041039361),IntegerVal (-2147418113)],VectorVal [IntegerVal (-2147434389),IntegerVal (-65536),IntegerVal (-2147418113),IntegerVal 1572962304]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s32(vcreate_s32(UINT64_C(0x7fffffff2ac38000)),
                          vcreate_s32(UINT64_C(0x8000ffffc1f2ffff)));
      arg2 = vcombine_s32(vcreate_s32(UINT64_C(0xffff00008000c06b)),
                          vcreate_s32(UINT64_C(0x5dc180008000ffff)));
      clear_neon_saturated();
      //  Expect: "result" = ffffffff000000000000000000000000
      result = vcltq_s32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 0);
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 1);
         exp = UINT64_C(0xffffffff00000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_493() {

{
   {
      float32x4_t arg1;
      float32x4_t arg2;
      uint32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"clt\", fnname = \"vcltq_f32\", rettype = \"uint32x4_t\", argtypes = \"[float32x4_t,float32x4_t]\", vals = [VectorVal [FloatVal 0.5523407459259033,FloatVal 0.47251009941101074,FloatVal 0.49579179286956787,FloatVal 0.3082699775695801],VectorVal [FloatVal 0.6587028503417969,FloatVal 0.28339672088623047,FloatVal 0.8724227547645569,FloatVal 0.994808554649353]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_f32(vcreate_f32(UINT64_C(0x3ef1ecd83f0d6634)),
                          vcreate_f32(UINT64_C(0x3e9dd5903efdd86c)));
      arg2 = vcombine_f32(vcreate_f32(UINT64_C(0x3e9119603f28a0c0)),
                          vcreate_f32(UINT64_C(0x3f7eabc63f5f5719)));
      clear_neon_saturated();
      //  Expect: "result" = ffffffffffffffff00000000ffffffff
      result = vcltq_f32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 0);
         exp = UINT64_C(0x00000000ffffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 1);
         exp = UINT64_C(0xffffffffffffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_494() {

{
   {
      uint8x16_t arg1;
      uint8x16_t arg2;
      uint8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"clt\", fnname = \"vcltq_u8\", rettype = \"uint8x16_t\", argtypes = \"[uint8x16_t,uint8x16_t]\", vals = [VectorVal [IntegerVal 0,IntegerVal 128,IntegerVal 128,IntegerVal 128,IntegerVal 231,IntegerVal 207,IntegerVal 128,IntegerVal 128,IntegerVal 128,IntegerVal 0,IntegerVal 127,IntegerVal 128,IntegerVal 0,IntegerVal 128,IntegerVal 255,IntegerVal 0],VectorVal [IntegerVal 128,IntegerVal 128,IntegerVal 255,IntegerVal 135,IntegerVal 128,IntegerVal 127,IntegerVal 128,IntegerVal 127,IntegerVal 127,IntegerVal 127,IntegerVal 128,IntegerVal 128,IntegerVal 127,IntegerVal 128,IntegerVal 255,IntegerVal 255]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u8(vcreate_u8(UINT64_C(0x8080cfe780808000)),
                         vcreate_u8(UINT64_C(0x00ff8000807f0080)));
      arg2 = vcombine_u8(vcreate_u8(UINT64_C(0x7f807f8087ff8080)),
                         vcreate_u8(UINT64_C(0xffff807f80807f7f)));
      clear_neon_saturated();
      //  Expect: "result" = ff0000ff00ffff0000000000ffff00ff
      result = vcltq_u8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 0);
         exp = UINT64_C(0x00000000ffff00ff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 1);
         exp = UINT64_C(0xff0000ff00ffff00);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_495() {

{
   {
      uint16x8_t arg1;
      uint16x8_t arg2;
      uint16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"clt\", fnname = \"vcltq_u16\", rettype = \"uint16x8_t\", argtypes = \"[uint16x8_t,uint16x8_t]\", vals = [VectorVal [IntegerVal 32767,IntegerVal 5593,IntegerVal 65535,IntegerVal 32767,IntegerVal 65535,IntegerVal 14875,IntegerVal 0,IntegerVal 32767],VectorVal [IntegerVal 0,IntegerVal 0,IntegerVal 0,IntegerVal 32767,IntegerVal 32767,IntegerVal 0,IntegerVal 0,IntegerVal 26652]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u16(vcreate_u16(UINT64_C(0x7fffffff15d97fff)),
                          vcreate_u16(UINT64_C(0x7fff00003a1bffff)));
      arg2 = vcombine_u16(vcreate_u16(UINT64_C(0x7fff000000000000)),
                          vcreate_u16(UINT64_C(0x681c000000007fff)));
      clear_neon_saturated();
      //  Expect: "result" = 00000000000000000000000000000000
      result = vcltq_u16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 0);
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 1);
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_496() {

{
   {
      uint32x4_t arg1;
      uint32x4_t arg2;
      uint32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"clt\", fnname = \"vcltq_u32\", rettype = \"uint32x4_t\", argtypes = \"[uint32x4_t,uint32x4_t]\", vals = [VectorVal [IntegerVal 2147516416,IntegerVal 2147433972,IntegerVal 920387583,IntegerVal 4294934528],VectorVal [IntegerVal 4294934528,IntegerVal 2605219840,IntegerVal 4294934527,IntegerVal 2147418112]], start_saturated = True}";
      int reported = 0;
      arg1 = vcombine_u32(vcreate_u32(UINT64_C(0x7fff3df480008000)),
                          vcreate_u32(UINT64_C(0xffff800036dbffff)));
      arg2 = vcombine_u32(vcreate_u32(UINT64_C(0x9b488000ffff8000)),
                          vcreate_u32(UINT64_C(0x7fff0000ffff7fff)));
      set_neon_saturated();
      //  Expect: "result" = 00000000ffffffffffffffffffffffff
      result = vcltq_u32(arg1, arg2);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 0);
         exp = UINT64_C(0xffffffffffffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 1);
         exp = UINT64_C(0x00000000ffffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_497() {

{
   {
      int64x1_t arg1;
      int64x1_t arg2;
      uint64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"clt\", fnname = \"vclt_s64\", rettype = \"uint64x1_t\", argtypes = \"[int64x1_t,int64x1_t]\", vals = [VectorVal [IntegerVal (-140741783289856)],VectorVal [IntegerVal (-5055940560599089152)]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s64(UINT64_C(0xffff7fff00008000));
      arg2 = vcreate_s64(UINT64_C(0xb9d5b0d900008000));
      clear_neon_saturated();
      //  Expect: "result" = 0000000000000000
      result = vclt_s64(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(result, 0);
      exp = 0;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_498() {

{
   {
      uint64x1_t arg1;
      uint64x1_t arg2;
      uint64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"clt\", fnname = \"vclt_u64\", rettype = \"uint64x1_t\", argtypes = \"[uint64x1_t,uint64x1_t]\", vals = [VectorVal [IntegerVal 18446603336221196288],VectorVal [IntegerVal 9223372036854710272]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u64(UINT64_C(0xffff800000000000));
      arg2 = vcreate_u64(UINT64_C(0x7fffffffffff0000));
      clear_neon_saturated();
      //  Expect: "result" = 0000000000000000
      result = vclt_u64(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(result, 0);
      exp = 0;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_499() {

{
   {
      float64x1_t arg1;
      float64x1_t arg2;
      uint64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"clt\", fnname = \"vclt_f64\", rettype = \"uint64x1_t\", argtypes = \"[float64x1_t,float64x1_t]\", vals = [VectorVal [FloatVal 0.28482556807416504],VectorVal [FloatVal 0.38538012985451475]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_f64(UINT64_C(0x3fd23a9504fc5cbe));
      arg2 = vcreate_f64(UINT64_C(0x3fd8aa116b903748));
      clear_neon_saturated();
      //  Expect: "result" = ffffffffffffffff
      result = vclt_f64(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(result, 0);
      exp = UINT64_C(0xffffffffffffffff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_500() {

{
   {
      int64x2_t arg1;
      int64x2_t arg2;
      uint64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"clt\", fnname = \"vcltq_s64\", rettype = \"uint64x2_t\", argtypes = \"[int64x2_t,int64x2_t]\", vals = [VectorVal [IntegerVal 281470681776127,IntegerVal 140741025038336],VectorVal [IntegerVal 9223090564025516032,IntegerVal (-9223231297219002368)]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s64(vcreate_s64(UINT64_C(0x0000ffff00007fff)),
                          vcreate_s64(UINT64_C(0x00008000d2cd8000)));
      arg2 = vcombine_s64(vcreate_s64(UINT64_C(0x7fff00007fff8000)),
                          vcreate_s64(UINT64_C(0x800080007fff0000)));
      clear_neon_saturated();
      //  Expect: "result" = 0000000000000000ffffffffffffffff
      result = vcltq_s64(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 0);
         exp = UINT64_C(0xffffffffffffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 1);
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_501() {

{
   {
      uint64x2_t arg1;
      uint64x2_t arg2;
      uint64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"clt\", fnname = \"vcltq_u64\", rettype = \"uint64x2_t\", argtypes = \"[uint64x2_t,uint64x2_t]\", vals = [VectorVal [IntegerVal 853432129386643456,IntegerVal 9223372039002193920],VectorVal [IntegerVal 9223096542619992064,IntegerVal 9223653507536524672]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u64(vcreate_u64(UINT64_C(0x0bd7ffffffff0000)),
                          vcreate_u64(UINT64_C(0x800000007fff0000)));
      arg2 = vcombine_u64(vcreate_u64(UINT64_C(0x7fff05707fff8000)),
                          vcreate_u64(UINT64_C(0x8000ffff00001580)));
      clear_neon_saturated();
      //  Expect: "result" = ffffffffffffffffffffffffffffffff
      result = vcltq_u64(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 0);
         exp = UINT64_C(0xffffffffffffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 1);
         exp = UINT64_C(0xffffffffffffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_502() {

{
   {
      float64x2_t arg1;
      float64x2_t arg2;
      uint64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"clt\", fnname = \"vcltq_f64\", rettype = \"uint64x2_t\", argtypes = \"[float64x2_t,float64x2_t]\", vals = [VectorVal [FloatVal 0.9625298142455496,FloatVal 0.7654008246886317],VectorVal [FloatVal 0.347785688040949,FloatVal 0.4631638556915244]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_f64(vcreate_f64(UINT64_C(0x3feecd0b533381c4)),
                          vcreate_f64(UINT64_C(0x3fe87e29decbcfb0)));
      arg2 = vcombine_f64(vcreate_f64(UINT64_C(0x3fd6421ee709c666)),
                          vcreate_f64(UINT64_C(0x3fdda47a0338995e)));
      clear_neon_saturated();
      //  Expect: "result" = 00000000000000000000000000000000
      result = vcltq_f64(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 0);
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 1);
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_503() {

{
   {
      int64_t arg1;
      int64_t arg2;
      uint64_t result;
      char* str1 = "ReproInfo2 {semantics = \"clt\", fnname = \"vcltd_s64\", rettype = \"uint64_t\", argtypes = \"[int64_t,int64_t]\", vals = [IntegerVal (-140740009103946),IntegerVal (-4100810811338063772)], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = INT64_C(-140740009103946);
      arg2 = INT64_C(-4100810811338063772);
      clear_neon_saturated();
      //  Expect: "result" = 0000000000000000
      result = vcltd_s64(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = 0;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_504() {

{
   {
      uint64_t arg1;
      uint64_t arg2;
      uint64_t result;
      char* str1 = "ReproInfo2 {semantics = \"clt\", fnname = \"vcltd_u64\", rettype = \"uint64_t\", argtypes = \"[uint64_t,uint64_t]\", vals = [IntegerVal 5694098041368239290,IntegerVal 9223231299366387712], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = UINT64_C(0x4f05800000005cba);
      arg2 = UINT64_C(0x7fff7fffffff8000);
      clear_neon_saturated();
      //  Expect: "result" = ffffffffffffffff
      result = vcltd_u64(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = UINT64_C(0xffffffffffffffff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_505() {

{
   {
      float32_t arg1;
      float32_t arg2;
      uint32_t result;
      char* str1 = "ReproInfo2 {semantics = \"clt\", fnname = \"vclts_f32\", rettype = \"uint32_t\", argtypes = \"[float32_t,float32_t]\", vals = [FloatVal 0.2716330885887146,FloatVal 0.23413169384002686], start_saturated = False}";
      int reported = 0;
      uint32_t got;
      uint32_t exp;
      arg1 = ((float32_t) 0.2716330885887146);
      arg2 = ((float32_t) 0.23413169384002686);
      clear_neon_saturated();
      //  Expect: "result" = 00000000
      result = vclts_f32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = 0;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIu32 " Got: %" PRIu32 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_506() {

{
   {
      float64_t arg1;
      float64_t arg2;
      uint64_t result;
      char* str1 = "ReproInfo2 {semantics = \"clt\", fnname = \"vcltd_f64\", rettype = \"uint64_t\", argtypes = \"[float64_t,float64_t]\", vals = [FloatVal 0.15370185953169202,FloatVal 0.6230598461396264], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = 0.15370185953169202;
      arg2 = 0.6230598461396264;
      clear_neon_saturated();
      //  Expect: "result" = ffffffffffffffff
      result = vcltd_f64(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = UINT64_C(0xffffffffffffffff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_507() {

{
   {
      float32x2_t arg1;
      float32x2_t arg2;
      uint32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"cage\", fnname = \"vcage_f32\", rettype = \"uint32x2_t\", argtypes = \"[float32x2_t,float32x2_t]\", vals = [VectorVal [FloatVal 0.8265987634658813,FloatVal 0.5422247052192688],VectorVal [FloatVal 0.4653276801109314,FloatVal 0.5733954310417175]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_f32(UINT64_C(0x3f0acf3d3f539bfa));
      arg2 = vcreate_f32(UINT64_C(0x3f12ca0b3eee3f6e));
      clear_neon_saturated();
      //  Expect: "result" = 00000000ffffffff
      result = vcage_f32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u32(result), 0);
      exp = UINT64_C(0x00000000ffffffff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_508() {

{
   {
      float64x1_t arg1;
      float64x1_t arg2;
      uint64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"cage\", fnname = \"vcage_f64\", rettype = \"uint64x1_t\", argtypes = \"[float64x1_t,float64x1_t]\", vals = [VectorVal [FloatVal 6.05068825537175e-2],VectorVal [FloatVal 0.227072232543014]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_f64(UINT64_C(0x3faefac213809410));
      arg2 = vcreate_f64(UINT64_C(0x3fcd10b3f24d0cc4));
      clear_neon_saturated();
      //  Expect: "result" = 0000000000000000
      result = vcage_f64(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(result, 0);
      exp = 0;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_509() {

{
   {
      float32x4_t arg1;
      float32x4_t arg2;
      uint32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"cage\", fnname = \"vcageq_f32\", rettype = \"uint32x4_t\", argtypes = \"[float32x4_t,float32x4_t]\", vals = [VectorVal [FloatVal 0.9453518390655518,FloatVal 0.8591511249542236,FloatVal 0.1291205883026123,FloatVal 0.5475019812583923],VectorVal [FloatVal 0.2016882300376892,FloatVal 0.4601432681083679,FloatVal 0.4625532031059265,FloatVal 8.801835775375366e-2]], start_saturated = True}";
      int reported = 0;
      arg1 = vcombine_f32(vcreate_f32(UINT64_C(0x3f5bf1543f720294)),
                          vcreate_f32(UINT64_C(0x3f0c29173e043830)));
      arg2 = vcombine_f32(vcreate_f32(UINT64_C(0x3eeb97e63e4e875c)),
                          vcreate_f32(UINT64_C(0x3db442f83eecd3c6)));
      set_neon_saturated();
      //  Expect: "result" = ffffffff00000000ffffffffffffffff
      result = vcageq_f32(arg1, arg2);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 0);
         exp = UINT64_C(0xffffffffffffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 1);
         exp = UINT64_C(0xffffffff00000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_510() {

{
   {
      float64x2_t arg1;
      float64x2_t arg2;
      uint64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"cage\", fnname = \"vcageq_f64\", rettype = \"uint64x2_t\", argtypes = \"[float64x2_t,float64x2_t]\", vals = [VectorVal [FloatVal 0.2832003976123896,FloatVal 0.21610966590814384],VectorVal [FloatVal 0.3128352349741744,FloatVal 0.2104791512073244]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_f64(vcreate_f64(UINT64_C(0x3fd21ff48f7d66f8)),
                          vcreate_f64(UINT64_C(0x3fcba97b45b66538)));
      arg2 = vcombine_f64(vcreate_f64(UINT64_C(0x3fd4057e13d00916)),
                          vcreate_f64(UINT64_C(0x3fcaf0fb17767024)));
      clear_neon_saturated();
      //  Expect: "result" = ffffffffffffffff0000000000000000
      result = vcageq_f64(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 0);
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 1);
         exp = UINT64_C(0xffffffffffffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_511() {

{
   {
      float32_t arg1;
      float32_t arg2;
      uint32_t result;
      char* str1 = "ReproInfo2 {semantics = \"cage\", fnname = \"vcages_f32\", rettype = \"uint32_t\", argtypes = \"[float32_t,float32_t]\", vals = [FloatVal 0.9626789093017578,FloatVal 0.7648783326148987], start_saturated = False}";
      int reported = 0;
      uint32_t got;
      uint32_t exp;
      arg1 = ((float32_t) 0.9626789093017578);
      arg2 = ((float32_t) 0.7648783326148987);
      clear_neon_saturated();
      //  Expect: "result" = ffffffff
      result = vcages_f32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = 4294967295U;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIu32 " Got: %" PRIu32 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_512() {

{
   {
      float64_t arg1;
      float64_t arg2;
      uint64_t result;
      char* str1 = "ReproInfo2 {semantics = \"cage\", fnname = \"vcaged_f64\", rettype = \"uint64_t\", argtypes = \"[float64_t,float64_t]\", vals = [FloatVal 0.44824326128571357,FloatVal 0.7791890415322047], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = 0.44824326128571357;
      arg2 = 0.7791890415322047;
      clear_neon_saturated();
      //  Expect: "result" = 0000000000000000
      result = vcaged_f64(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = 0;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_513() {

{
   {
      float32x2_t arg1;
      float32x2_t arg2;
      uint32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"cale\", fnname = \"vcale_f32\", rettype = \"uint32x2_t\", argtypes = \"[float32x2_t,float32x2_t]\", vals = [VectorVal [FloatVal 0.3334415555000305,FloatVal 5.344957113265991e-2],VectorVal [FloatVal 0.45612579584121704,FloatVal 0.41214364767074585]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_f32(UINT64_C(0x3d5aedf03eaab8da));
      arg2 = vcreate_f32(UINT64_C(0x3ed3047e3ee98952));
      clear_neon_saturated();
      //  Expect: "result" = ffffffffffffffff
      result = vcale_f32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u32(result), 0);
      exp = UINT64_C(0xffffffffffffffff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_514() {

{
   {
      float64x1_t arg1;
      float64x1_t arg2;
      uint64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"cale\", fnname = \"vcale_f64\", rettype = \"uint64x1_t\", argtypes = \"[float64x1_t,float64x1_t]\", vals = [VectorVal [FloatVal 0.8818025694395007],VectorVal [FloatVal 0.1328722572720792]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_f64(UINT64_C(0x3fec37ba05a8af83));
      arg2 = vcreate_f64(UINT64_C(0x3fc101f547c3bf64));
      clear_neon_saturated();
      //  Expect: "result" = 0000000000000000
      result = vcale_f64(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(result, 0);
      exp = 0;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_515() {

{
   {
      float32x4_t arg1;
      float32x4_t arg2;
      uint32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"cale\", fnname = \"vcaleq_f32\", rettype = \"uint32x4_t\", argtypes = \"[float32x4_t,float32x4_t]\", vals = [VectorVal [FloatVal 0.7191770076751709,FloatVal 0.7265318632125854,FloatVal 0.8449756503105164,FloatVal 0.2889687418937683],VectorVal [FloatVal 0.4999768137931824,FloatVal 0.3846147656440735,FloatVal 0.6839826703071594,FloatVal 0.9385984539985657]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_f32(vcreate_f32(UINT64_C(0x3f39fdfe3f381bfc)),
                          vcreate_f32(UINT64_C(0x3e93f3b63f585053)));
      arg2 = vcombine_f32(vcreate_f32(UINT64_C(0x3ec4ec3a3efffcf6)),
                          vcreate_f32(UINT64_C(0x3f7047fd3f2f197d)));
      clear_neon_saturated();
      //  Expect: "result" = ffffffff000000000000000000000000
      result = vcaleq_f32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 0);
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 1);
         exp = UINT64_C(0xffffffff00000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_516() {

{
   {
      float64x2_t arg1;
      float64x2_t arg2;
      uint64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"cale\", fnname = \"vcaleq_f64\", rettype = \"uint64x2_t\", argtypes = \"[float64x2_t,float64x2_t]\", vals = [VectorVal [FloatVal 0.8678504072731913,FloatVal 0.37319232416425985],VectorVal [FloatVal 0.2889595753526085,FloatVal 0.9349986110875993]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_f64(vcreate_f64(UINT64_C(0x3febc56e37a1e05b)),
                          vcreate_f64(UINT64_C(0x3fd7e2620ed9d6a8)));
      arg2 = vcombine_f64(vcreate_f64(UINT64_C(0x3fd27e504d805a22)),
                          vcreate_f64(UINT64_C(0x3fedeb82350da737)));
      clear_neon_saturated();
      //  Expect: "result" = ffffffffffffffff0000000000000000
      result = vcaleq_f64(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 0);
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 1);
         exp = UINT64_C(0xffffffffffffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_517() {

{
   {
      float32_t arg1;
      float32_t arg2;
      uint32_t result;
      char* str1 = "ReproInfo2 {semantics = \"cale\", fnname = \"vcales_f32\", rettype = \"uint32_t\", argtypes = \"[float32_t,float32_t]\", vals = [FloatVal 0.5773485898971558,FloatVal 0.9942719340324402], start_saturated = False}";
      int reported = 0;
      uint32_t got;
      uint32_t exp;
      arg1 = ((float32_t) 0.5773485898971558);
      arg2 = ((float32_t) 0.9942719340324402);
      clear_neon_saturated();
      //  Expect: "result" = ffffffff
      result = vcales_f32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = 4294967295U;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIu32 " Got: %" PRIu32 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_518() {

{
   {
      float64_t arg1;
      float64_t arg2;
      uint64_t result;
      char* str1 = "ReproInfo2 {semantics = \"cale\", fnname = \"vcaled_f64\", rettype = \"uint64_t\", argtypes = \"[float64_t,float64_t]\", vals = [FloatVal 0.7661549478299321,FloatVal 0.5120861815517899], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = 0.7661549478299321;
      arg2 = 0.5120861815517899;
      clear_neon_saturated();
      //  Expect: "result" = 0000000000000000
      result = vcaled_f64(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = 0;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_519() {

{
   {
      float32x2_t arg1;
      float32x2_t arg2;
      uint32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"cagt\", fnname = \"vcagt_f32\", rettype = \"uint32x2_t\", argtypes = \"[float32x2_t,float32x2_t]\", vals = [VectorVal [FloatVal 0.2758222818374634,FloatVal 0.9515084028244019],VectorVal [FloatVal 0.9614004492759705,FloatVal 0.9291876554489136]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_f32(UINT64_C(0x3f73960e3e8d3894));
      arg2 = vcreate_f32(UINT64_C(0x3f6ddf3e3f761e57));
      clear_neon_saturated();
      //  Expect: "result" = ffffffff00000000
      result = vcagt_f32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u32(result), 0);
      exp = UINT64_C(0xffffffff00000000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_520() {

{
   {
      float64x1_t arg1;
      float64x1_t arg2;
      uint64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"cagt\", fnname = \"vcagt_f64\", rettype = \"uint64x1_t\", argtypes = \"[float64x1_t,float64x1_t]\", vals = [VectorVal [FloatVal 0.408427509588261],VectorVal [FloatVal 0.9976144139340899]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_f64(UINT64_C(0x3fda23ad231df8c0));
      arg2 = vcreate_f64(UINT64_C(0x3fefec75103baf16));
      clear_neon_saturated();
      //  Expect: "result" = 0000000000000000
      result = vcagt_f64(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(result, 0);
      exp = 0;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_521() {

{
   {
      float32x4_t arg1;
      float32x4_t arg2;
      uint32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"cagt\", fnname = \"vcagtq_f32\", rettype = \"uint32x4_t\", argtypes = \"[float32x4_t,float32x4_t]\", vals = [VectorVal [FloatVal 0.25454217195510864,FloatVal 0.7499964237213135,FloatVal 0.16991418600082397,FloatVal 0.6354023218154907],VectorVal [FloatVal 0.24277371168136597,FloatVal 0.8917063474655151,FloatVal 0.24627047777175903,FloatVal 0.30449360609054565]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_f32(vcreate_f32(UINT64_C(0x3f3fffc43e82535a)),
                          vcreate_f32(UINT64_C(0x3f22a9ba3e2dfdfc)));
      arg2 = vcombine_f32(vcreate_f32(UINT64_C(0x3f6446de3e7899ac)),
                          vcreate_f32(UINT64_C(0x3e9be6963e7c2e54)));
      clear_neon_saturated();
      //  Expect: "result" = ffffffff0000000000000000ffffffff
      result = vcagtq_f32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 0);
         exp = UINT64_C(0x00000000ffffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 1);
         exp = UINT64_C(0xffffffff00000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_522() {

{
   {
      float64x2_t arg1;
      float64x2_t arg2;
      uint64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"cagt\", fnname = \"vcagtq_f64\", rettype = \"uint64x2_t\", argtypes = \"[float64x2_t,float64x2_t]\", vals = [VectorVal [FloatVal 0.15077314489099725,FloatVal 0.5829992159903141],VectorVal [FloatVal 0.7884980952092524,FloatVal 0.7351371072697589]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_f64(vcreate_f64(UINT64_C(0x3fc34c88cf3600e8)),
                          vcreate_f64(UINT64_C(0x3fe2a7edf8c8b48c)));
      arg2 = vcombine_f64(vcreate_f64(UINT64_C(0x3fe93b605b7c399e)),
                          vcreate_f64(UINT64_C(0x3fe7863e413996cd)));
      clear_neon_saturated();
      //  Expect: "result" = 00000000000000000000000000000000
      result = vcagtq_f64(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 0);
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 1);
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_523() {

{
   {
      float32_t arg1;
      float32_t arg2;
      uint32_t result;
      char* str1 = "ReproInfo2 {semantics = \"cagt\", fnname = \"vcagts_f32\", rettype = \"uint32_t\", argtypes = \"[float32_t,float32_t]\", vals = [FloatVal 0.5951930284500122,FloatVal 0.7496076226234436], start_saturated = False}";
      int reported = 0;
      uint32_t got;
      uint32_t exp;
      arg1 = ((float32_t) 0.5951930284500122);
      arg2 = ((float32_t) 0.7496076226234436);
      clear_neon_saturated();
      //  Expect: "result" = 00000000
      result = vcagts_f32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = 0;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIu32 " Got: %" PRIu32 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_524() {

{
   {
      float64_t arg1;
      float64_t arg2;
      uint64_t result;
      char* str1 = "ReproInfo2 {semantics = \"cagt\", fnname = \"vcagtd_f64\", rettype = \"uint64_t\", argtypes = \"[float64_t,float64_t]\", vals = [FloatVal 0.45699282367396143,FloatVal 0.7939129604060611], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = 0.45699282367396143;
      arg2 = 0.7939129604060611;
      clear_neon_saturated();
      //  Expect: "result" = 0000000000000000
      result = vcagtd_f64(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = 0;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_525() {

{
   {
      float32x2_t arg1;
      float32x2_t arg2;
      uint32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"calt\", fnname = \"vcalt_f32\", rettype = \"uint32x2_t\", argtypes = \"[float32x2_t,float32x2_t]\", vals = [VectorVal [FloatVal 0.5212456583976746,FloatVal 0.7869763374328613],VectorVal [FloatVal 0.5620397329330444,FloatVal 0.3296055197715759]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_f32(UINT64_C(0x3f4977483f05705b));
      arg2 = vcreate_f32(UINT64_C(0x3ea8c20e3f0fe1d6));
      clear_neon_saturated();
      //  Expect: "result" = 00000000ffffffff
      result = vcalt_f32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u32(result), 0);
      exp = UINT64_C(0x00000000ffffffff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_526() {

{
   {
      float64x1_t arg1;
      float64x1_t arg2;
      uint64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"calt\", fnname = \"vcalt_f64\", rettype = \"uint64x1_t\", argtypes = \"[float64x1_t,float64x1_t]\", vals = [VectorVal [FloatVal 0.6979907517290026],VectorVal [FloatVal 0.948533553310651]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_f64(UINT64_C(0x3fe655f0b372c4c9));
      arg2 = vcreate_f64(UINT64_C(0x3fee5a6309d417e9));
      clear_neon_saturated();
      //  Expect: "result" = ffffffffffffffff
      result = vcalt_f64(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(result, 0);
      exp = UINT64_C(0xffffffffffffffff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_527() {

{
   {
      float32x4_t arg1;
      float32x4_t arg2;
      uint32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"calt\", fnname = \"vcaltq_f32\", rettype = \"uint32x4_t\", argtypes = \"[float32x4_t,float32x4_t]\", vals = [VectorVal [FloatVal 0.4147171378135681,FloatVal 0.47538089752197266,FloatVal 0.8068545460700989,FloatVal 0.9567768573760986],VectorVal [FloatVal 0.3370512127876282,FloatVal 0.11139750480651855,FloatVal 0.6265203356742859,FloatVal 0.5583425164222717]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_f32(vcreate_f32(UINT64_C(0x3ef365203ed455ce)),
                          vcreate_f32(UINT64_C(0x3f74ef543f4e8e05)));
      arg2 = vcombine_f32(vcreate_f32(UINT64_C(0x3de424603eac91fa)),
                          vcreate_f32(UINT64_C(0x3f0eef893f2063a3)));
      clear_neon_saturated();
      //  Expect: "result" = 00000000000000000000000000000000
      result = vcaltq_f32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 0);
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 1);
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_528() {

{
   {
      float64x2_t arg1;
      float64x2_t arg2;
      uint64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"calt\", fnname = \"vcaltq_f64\", rettype = \"uint64x2_t\", argtypes = \"[float64x2_t,float64x2_t]\", vals = [VectorVal [FloatVal 0.5896391878408511,FloatVal 0.8395618277712328],VectorVal [FloatVal 0.9282563487933934,FloatVal 0.4724923076519557]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_f64(vcreate_f64(UINT64_C(0x3fe2de530086ed36)),
                          vcreate_f64(UINT64_C(0x3feaddb0c427eaf1)));
      arg2 = vcombine_f64(vcreate_f64(UINT64_C(0x3fedb446a88be75f)),
                          vcreate_f64(UINT64_C(0x3fde3d50603e8296)));
      clear_neon_saturated();
      //  Expect: "result" = 0000000000000000ffffffffffffffff
      result = vcaltq_f64(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 0);
         exp = UINT64_C(0xffffffffffffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 1);
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_529() {

{
   {
      float32_t arg1;
      float32_t arg2;
      uint32_t result;
      char* str1 = "ReproInfo2 {semantics = \"calt\", fnname = \"vcalts_f32\", rettype = \"uint32_t\", argtypes = \"[float32_t,float32_t]\", vals = [FloatVal 0.6735090017318726,FloatVal 0.8812708854675293], start_saturated = False}";
      int reported = 0;
      uint32_t got;
      uint32_t exp;
      arg1 = ((float32_t) 0.6735090017318726);
      arg2 = ((float32_t) 0.8812708854675293);
      clear_neon_saturated();
      //  Expect: "result" = ffffffff
      result = vcalts_f32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = 4294967295U;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIu32 " Got: %" PRIu32 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_530() {

{
   {
      float64_t arg1;
      float64_t arg2;
      uint64_t result;
      char* str1 = "ReproInfo2 {semantics = \"calt\", fnname = \"vcaltd_f64\", rettype = \"uint64_t\", argtypes = \"[float64_t,float64_t]\", vals = [FloatVal 0.19680649212425727,FloatVal 0.3949434017495095], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = 0.19680649212425727;
      arg2 = 0.3949434017495095;
      clear_neon_saturated();
      //  Expect: "result" = ffffffffffffffff
      result = vcaltd_f64(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = UINT64_C(0xffffffffffffffff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_531() {

{
   {
      int8x8_t arg1;
      int8x8_t arg2;
      uint8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"tst\", fnname = \"vtst_s8\", rettype = \"uint8x8_t\", argtypes = \"[int8x8_t,int8x8_t]\", vals = [VectorVal [IntegerVal 127,IntegerVal (-128),IntegerVal (-1),IntegerVal (-1),IntegerVal (-10),IntegerVal 127,IntegerVal 0,IntegerVal 95],VectorVal [IntegerVal 127,IntegerVal 127,IntegerVal 127,IntegerVal (-1),IntegerVal 127,IntegerVal (-7),IntegerVal 0,IntegerVal (-128)]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s8(UINT64_C(0x5f007ff6ffff807f));
      arg2 = vcreate_s8(UINT64_C(0x8000f97fff7f7f7f));
      clear_neon_saturated();
      //  Expect: "result" = 0000ffffffff00ff
      result = vtst_s8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u8(result), 0);
      exp = UINT64_C(0x0000ffffffff00ff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_532() {

{
   {
      int16x4_t arg1;
      int16x4_t arg2;
      uint16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"tst\", fnname = \"vtst_s16\", rettype = \"uint16x4_t\", argtypes = \"[int16x4_t,int16x4_t]\", vals = [VectorVal [IntegerVal (-1),IntegerVal 32767,IntegerVal 32767,IntegerVal 0],VectorVal [IntegerVal (-32768),IntegerVal 32767,IntegerVal 0,IntegerVal (-14125)]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s16(UINT64_C(0x00007fff7fffffff));
      arg2 = vcreate_s16(UINT64_C(0xc8d300007fff8000));
      clear_neon_saturated();
      //  Expect: "result" = 00000000ffffffff
      result = vtst_s16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u16(result), 0);
      exp = UINT64_C(0x00000000ffffffff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_533() {

{
   {
      int32x2_t arg1;
      int32x2_t arg2;
      uint32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"tst\", fnname = \"vtst_s32\", rettype = \"uint32x2_t\", argtypes = \"[int32x2_t,int32x2_t]\", vals = [VectorVal [IntegerVal 2147483647,IntegerVal (-820150272)],VectorVal [IntegerVal 2147450879,IntegerVal (-2147468707)]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s32(UINT64_C(0xcf1d80007fffffff));
      arg2 = vcreate_s32(UINT64_C(0x80003a5d7fff7fff));
      clear_neon_saturated();
      //  Expect: "result" = ffffffffffffffff
      result = vtst_s32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u32(result), 0);
      exp = UINT64_C(0xffffffffffffffff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_534() {

{
   {
      uint8x8_t arg1;
      uint8x8_t arg2;
      uint8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"tst\", fnname = \"vtst_u8\", rettype = \"uint8x8_t\", argtypes = \"[uint8x8_t,uint8x8_t]\", vals = [VectorVal [IntegerVal 213,IntegerVal 128,IntegerVal 43,IntegerVal 128,IntegerVal 255,IntegerVal 128,IntegerVal 0,IntegerVal 127],VectorVal [IntegerVal 127,IntegerVal 3,IntegerVal 127,IntegerVal 255,IntegerVal 44,IntegerVal 0,IntegerVal 128,IntegerVal 255]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u8(UINT64_C(0x7f0080ff802b80d5));
      arg2 = vcreate_u8(UINT64_C(0xff80002cff7f037f));
      clear_neon_saturated();
      //  Expect: "result" = ff0000ffffff00ff
      result = vtst_u8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u8(result), 0);
      exp = UINT64_C(0xff0000ffffff00ff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_535() {

{
   {
      uint16x4_t arg1;
      uint16x4_t arg2;
      uint16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"tst\", fnname = \"vtst_u16\", rettype = \"uint16x4_t\", argtypes = \"[uint16x4_t,uint16x4_t]\", vals = [VectorVal [IntegerVal 32767,IntegerVal 0,IntegerVal 65535,IntegerVal 32768],VectorVal [IntegerVal 0,IntegerVal 32767,IntegerVal 32768,IntegerVal 65535]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u16(UINT64_C(0x8000ffff00007fff));
      arg2 = vcreate_u16(UINT64_C(0xffff80007fff0000));
      clear_neon_saturated();
      //  Expect: "result" = ffffffff00000000
      result = vtst_u16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u16(result), 0);
      exp = UINT64_C(0xffffffff00000000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_536() {

{
   {
      uint32x2_t arg1;
      uint32x2_t arg2;
      uint32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"tst\", fnname = \"vtst_u32\", rettype = \"uint32x2_t\", argtypes = \"[uint32x2_t,uint32x2_t]\", vals = [VectorVal [IntegerVal 2147516416,IntegerVal 4294940144],VectorVal [IntegerVal 65535,IntegerVal 4294955016]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u32(UINT64_C(0xffff95f080008000));
      arg2 = vcreate_u32(UINT64_C(0xffffd0080000ffff));
      clear_neon_saturated();
      //  Expect: "result" = ffffffffffffffff
      result = vtst_u32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u32(result), 0);
      exp = UINT64_C(0xffffffffffffffff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_537() {

{
   {
      int8x16_t arg1;
      int8x16_t arg2;
      uint8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"tst\", fnname = \"vtstq_s8\", rettype = \"uint8x16_t\", argtypes = \"[int8x16_t,int8x16_t]\", vals = [VectorVal [IntegerVal (-1),IntegerVal 29,IntegerVal 38,IntegerVal (-1),IntegerVal (-128),IntegerVal (-128),IntegerVal (-1),IntegerVal 127,IntegerVal (-128),IntegerVal (-1),IntegerVal 127,IntegerVal 127,IntegerVal 127,IntegerVal (-128),IntegerVal (-1),IntegerVal (-100)],VectorVal [IntegerVal (-128),IntegerVal (-128),IntegerVal 7,IntegerVal (-128),IntegerVal 127,IntegerVal (-1),IntegerVal (-128),IntegerVal (-1),IntegerVal (-128),IntegerVal 0,IntegerVal 12,IntegerVal 127,IntegerVal 59,IntegerVal 0,IntegerVal (-1),IntegerVal 0]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s8(vcreate_s8(UINT64_C(0x7fff8080ff261dff)),
                         vcreate_s8(UINT64_C(0x9cff807f7f7fff80)));
      arg2 = vcombine_s8(vcreate_s8(UINT64_C(0xff80ff7f80078080)),
                         vcreate_s8(UINT64_C(0x00ff003b7f0c0080)));
      clear_neon_saturated();
      //  Expect: "result" = 00ff00ffffff00ffffffff00ffff00ff
      result = vtstq_s8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 0);
         exp = UINT64_C(0xffffff00ffff00ff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 1);
         exp = UINT64_C(0x00ff00ffffff00ff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_538() {

{
   {
      int16x8_t arg1;
      int16x8_t arg2;
      uint16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"tst\", fnname = \"vtstq_s16\", rettype = \"uint16x8_t\", argtypes = \"[int16x8_t,int16x8_t]\", vals = [VectorVal [IntegerVal (-32768),IntegerVal (-7334),IntegerVal (-1),IntegerVal 32767,IntegerVal (-1),IntegerVal (-12699),IntegerVal (-17702),IntegerVal (-8670)],VectorVal [IntegerVal 32767,IntegerVal 0,IntegerVal (-32768),IntegerVal 16364,IntegerVal (-32768),IntegerVal (-3155),IntegerVal (-32768),IntegerVal (-32768)]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s16(vcreate_s16(UINT64_C(0x7fffffffe35a8000)),
                          vcreate_s16(UINT64_C(0xde22badace65ffff)));
      arg2 = vcombine_s16(vcreate_s16(UINT64_C(0x3fec800000007fff)),
                          vcreate_s16(UINT64_C(0x80008000f3ad8000)));
      clear_neon_saturated();
      //  Expect: "result" = ffffffffffffffffffffffff00000000
      result = vtstq_s16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 0);
         exp = UINT64_C(0xffffffff00000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 1);
         exp = UINT64_C(0xffffffffffffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_539() {

{
   {
      int32x4_t arg1;
      int32x4_t arg2;
      uint32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"tst\", fnname = \"vtstq_s32\", rettype = \"uint32x4_t\", argtypes = \"[int32x4_t,int32x4_t]\", vals = [VectorVal [IntegerVal 1017020415,IntegerVal 32768,IntegerVal (-32768),IntegerVal (-2147450880)],VectorVal [IntegerVal (-65536),IntegerVal 2147418112,IntegerVal 2147452029,IntegerVal 11671]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s32(vcreate_s32(UINT64_C(0x000080003c9e7fff)),
                          vcreate_s32(UINT64_C(0x80008000ffff8000)));
      arg2 = vcombine_s32(vcreate_s32(UINT64_C(0x7fff0000ffff0000)),
                          vcreate_s32(UINT64_C(0x00002d977fff847d)));
      clear_neon_saturated();
      //  Expect: "result" = 00000000ffffffff00000000ffffffff
      result = vtstq_s32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 0);
         exp = UINT64_C(0x00000000ffffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 1);
         exp = UINT64_C(0x00000000ffffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_540() {

{
   {
      uint8x16_t arg1;
      uint8x16_t arg2;
      uint8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"tst\", fnname = \"vtstq_u8\", rettype = \"uint8x16_t\", argtypes = \"[uint8x16_t,uint8x16_t]\", vals = [VectorVal [IntegerVal 135,IntegerVal 180,IntegerVal 128,IntegerVal 94,IntegerVal 128,IntegerVal 88,IntegerVal 132,IntegerVal 0,IntegerVal 255,IntegerVal 0,IntegerVal 255,IntegerVal 127,IntegerVal 0,IntegerVal 128,IntegerVal 0,IntegerVal 128],VectorVal [IntegerVal 128,IntegerVal 128,IntegerVal 235,IntegerVal 255,IntegerVal 255,IntegerVal 0,IntegerVal 255,IntegerVal 179,IntegerVal 15,IntegerVal 73,IntegerVal 127,IntegerVal 0,IntegerVal 128,IntegerVal 127,IntegerVal 95,IntegerVal 127]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u8(vcreate_u8(UINT64_C(0x008458805e80b487)),
                         vcreate_u8(UINT64_C(0x800080007fff00ff)));
      arg2 = vcombine_u8(vcreate_u8(UINT64_C(0xb3ff00ffffeb8080)),
                         vcreate_u8(UINT64_C(0x7f5f7f80007f490f)));
      clear_neon_saturated();
      //  Expect: "result" = 0000000000ff00ff00ff00ffffffffff
      result = vtstq_u8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 0);
         exp = UINT64_C(0x00ff00ffffffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 1);
         exp = UINT64_C(0x0000000000ff00ff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_541() {

{
   {
      uint16x8_t arg1;
      uint16x8_t arg2;
      uint16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"tst\", fnname = \"vtstq_u16\", rettype = \"uint16x8_t\", argtypes = \"[uint16x8_t,uint16x8_t]\", vals = [VectorVal [IntegerVal 32767,IntegerVal 2107,IntegerVal 43601,IntegerVal 32768,IntegerVal 65535,IntegerVal 65535,IntegerVal 65535,IntegerVal 0],VectorVal [IntegerVal 65535,IntegerVal 0,IntegerVal 371,IntegerVal 32768,IntegerVal 65535,IntegerVal 32767,IntegerVal 0,IntegerVal 65535]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u16(vcreate_u16(UINT64_C(0x8000aa51083b7fff)),
                          vcreate_u16(UINT64_C(0x0000ffffffffffff)));
      arg2 = vcombine_u16(vcreate_u16(UINT64_C(0x800001730000ffff)),
                          vcreate_u16(UINT64_C(0xffff00007fffffff)));
      clear_neon_saturated();
      //  Expect: "result" = 00000000ffffffffffffffff0000ffff
      result = vtstq_u16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 0);
         exp = UINT64_C(0xffffffff0000ffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 1);
         exp = UINT64_C(0x00000000ffffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_542() {

{
   {
      uint32x4_t arg1;
      uint32x4_t arg2;
      uint32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"tst\", fnname = \"vtstq_u32\", rettype = \"uint32x4_t\", argtypes = \"[uint32x4_t,uint32x4_t]\", vals = [VectorVal [IntegerVal 4294934528,IntegerVal 4294945386,IntegerVal 4294901760,IntegerVal 2147516415],VectorVal [IntegerVal 1180991487,IntegerVal 2147450879,IntegerVal 2147418112,IntegerVal 2147483647]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u32(vcreate_u32(UINT64_C(0xffffaa6affff8000)),
                          vcreate_u32(UINT64_C(0x80007fffffff0000)));
      arg2 = vcombine_u32(vcreate_u32(UINT64_C(0x7fff7fff46647fff)),
                          vcreate_u32(UINT64_C(0x7fffffff7fff0000)));
      clear_neon_saturated();
      //  Expect: "result" = ffffffffffffffffffffffffffffffff
      result = vtstq_u32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 0);
         exp = UINT64_C(0xffffffffffffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 1);
         exp = UINT64_C(0xffffffffffffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_543() {

{
   {
      int64x1_t arg1;
      int64x1_t arg2;
      uint64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"tst\", fnname = \"vtst_s64\", rettype = \"uint64x1_t\", argtypes = \"[int64x1_t,int64x1_t]\", vals = [VectorVal [IntegerVal 5882916286295462236],VectorVal [IntegerVal 281470681808895]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s64(UINT64_C(0x51a451318000515c));
      arg2 = vcreate_s64(UINT64_C(0x0000ffff0000ffff));
      clear_neon_saturated();
      //  Expect: "result" = ffffffffffffffff
      result = vtst_s64(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(result, 0);
      exp = UINT64_C(0xffffffffffffffff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_544() {

{
   {
      uint64x1_t arg1;
      uint64x1_t arg2;
      uint64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"tst\", fnname = \"vtst_u64\", rettype = \"uint64x1_t\", argtypes = \"[uint64x1_t,uint64x1_t]\", vals = [VectorVal [IntegerVal 9223090564025578537],VectorVal [IntegerVal 9223512778638094904]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u64(UINT64_C(0x7fff000080007429));
      arg2 = vcreate_u64(UINT64_C(0x80008000fffff238));
      clear_neon_saturated();
      //  Expect: "result" = ffffffffffffffff
      result = vtst_u64(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(result, 0);
      exp = UINT64_C(0xffffffffffffffff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_545() {

{
   {
      poly8x8_t arg1;
      poly8x8_t arg2;
      uint8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"tst\", fnname = \"vtst_p8\", rettype = \"uint8x8_t\", argtypes = \"[poly8x8_t,poly8x8_t]\", vals = [VectorVal [PolyVal [1,0,0,0,1,0,0,0],PolyVal [0,0,1,0,0,0,1,1],PolyVal [1,1,0,1,0,1,0,1],PolyVal [1,1,1,0,0,0,1,1],PolyVal [1,1,0,0,0,1,0,1],PolyVal [0,1,0,1,0,1,0,1],PolyVal [0,1,1,1,1,1,0,0],PolyVal [1,1,0,0,1,0,1,0]],VectorVal [PolyVal [0,1,1,0,1,1,0,0],PolyVal [1,1,1,1,1,1,1,0],PolyVal [1,1,0,1,0,0,0,0],PolyVal [1,1,0,1,0,1,1,0],PolyVal [0,0,1,1,0,1,0,0],PolyVal [1,0,1,1,0,1,1,1],PolyVal [1,0,1,0,0,1,1,1],PolyVal [1,0,1,1,1,0,0,0]]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_p8(UINT64_C(0x533eaaa3c7abc411));
      arg2 = vcreate_p8(UINT64_C(0x1de5ed2c6b0b7f36));
      clear_neon_saturated();
      //  Expect: "result" = ffffffffffffffff
      result = vtst_p8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u8(result), 0);
      exp = UINT64_C(0xffffffffffffffff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_546() {

{
   {
      poly16x4_t arg1;
      poly16x4_t arg2;
      uint16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"tst\", fnname = \"vtst_p16\", rettype = \"uint16x4_t\", argtypes = \"[poly16x4_t,poly16x4_t]\", vals = [VectorVal [PolyVal [0,1,0,0,0,0,0,1,1,1,1,0,0,0,0,1],PolyVal [1,0,1,0,0,1,0,0,1,0,1,1,1,0,0,0],PolyVal [0,0,1,1,1,0,0,0,0,1,1,1,1,1,0,1],PolyVal [0,0,0,0,0,0,0,1,0,1,1,0,1,0,0,0]],VectorVal [PolyVal [0,1,1,0,1,0,1,1,0,1,1,0,1,0,1,0],PolyVal [1,1,0,0,0,0,0,0,0,0,1,0,1,0,1,0],PolyVal [1,1,1,1,1,0,0,0,0,1,1,0,0,1,0,0],PolyVal [1,0,1,0,0,1,1,0,1,0,1,1,0,0,0,0]]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_p16(UINT64_C(0x1680be1c1d258782));
      arg2 = vcreate_p16(UINT64_C(0x0d65261f540356d6));
      clear_neon_saturated();
      //  Expect: "result" = ffffffffffffffff
      result = vtst_p16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u16(result), 0);
      exp = UINT64_C(0xffffffffffffffff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_547() {

{
   {
      int64x2_t arg1;
      int64x2_t arg2;
      uint64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"tst\", fnname = \"vtstq_s64\", rettype = \"uint64x2_t\", argtypes = \"[int64x2_t,int64x2_t]\", vals = [VectorVal [IntegerVal 281472829259776,IntegerVal (-9223257382702776320)],VectorVal [IntegerVal 9223364184510562304,IntegerVal (-281472829199339)]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s64(vcreate_s64(UINT64_C(0x0000ffff80008000)),
                          vcreate_s64(UINT64_C(0x8000684700008000)));
      arg2 = vcombine_s64(vcreate_s64(UINT64_C(0x7ffff8dbbbd00000)),
                          vcreate_s64(UINT64_C(0xffff000080006c15)));
      clear_neon_saturated();
      //  Expect: "result" = ffffffffffffffffffffffffffffffff
      result = vtstq_s64(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 0);
         exp = UINT64_C(0xffffffffffffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 1);
         exp = UINT64_C(0xffffffffffffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_548() {

{
   {
      uint64x2_t arg1;
      uint64x2_t arg2;
      uint64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"tst\", fnname = \"vtstq_u64\", rettype = \"uint64x2_t\", argtypes = \"[uint64x2_t,uint64x2_t]\", vals = [VectorVal [IntegerVal 9223372038932889599,IntegerVal 9223653507698982911],VectorVal [IntegerVal 9223653507536551936,IntegerVal 124667868157255]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u64(vcreate_u64(UINT64_C(0x800000007bdd7fff)),
                          vcreate_u64(UINT64_C(0x8000ffff09aeffff)));
      arg2 = vcombine_u64(vcreate_u64(UINT64_C(0x8000ffff00008000)),
                          vcreate_u64(UINT64_C(0x000071627fff1547)));
      clear_neon_saturated();
      //  Expect: "result" = ffffffffffffffffffffffffffffffff
      result = vtstq_u64(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 0);
         exp = UINT64_C(0xffffffffffffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 1);
         exp = UINT64_C(0xffffffffffffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_549() {

{
   {
      poly8x16_t arg1;
      poly8x16_t arg2;
      uint8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"tst\", fnname = \"vtstq_p8\", rettype = \"uint8x16_t\", argtypes = \"[poly8x16_t,poly8x16_t]\", vals = [VectorVal [PolyVal [1,0,0,0,0,1,0,1],PolyVal [1,1,0,1,0,0,0,1],PolyVal [0,1,1,1,0,1,0,0],PolyVal [0,1,1,1,1,1,0,0],PolyVal [1,0,1,0,1,1,1,0],PolyVal [0,1,1,0,0,1,1,1],PolyVal [1,1,0,0,1,1,0,1],PolyVal [1,0,0,0,1,1,1,0],PolyVal [0,1,0,1,0,1,1,1],PolyVal [1,0,1,0,1,0,1,1],PolyVal [1,1,1,1,1,1,1,1],PolyVal [1,0,1,1,0,1,1,0],PolyVal [1,1,1,1,1,0,0,0],PolyVal [0,1,1,1,1,1,1,1],PolyVal [1,1,1,1,1,0,0,0],PolyVal [1,0,1,0,0,1,1,1]],VectorVal [PolyVal [1,1,0,0,0,1,0,0],PolyVal [1,0,1,1,1,0,1,0],PolyVal [1,0,1,0,1,0,1,1],PolyVal [1,1,0,0,1,1,0,1],PolyVal [1,0,0,0,0,0,1,1],PolyVal [1,1,1,1,1,0,1,0],PolyVal [1,0,1,0,0,0,0,0],PolyVal [0,0,1,0,0,1,1,0],PolyVal [1,1,1,1,1,0,1,0],PolyVal [0,0,0,0,0,0,0,1],PolyVal [1,1,1,1,0,0,1,1],PolyVal [0,0,0,0,0,1,0,1],PolyVal [1,0,0,1,1,1,1,0],PolyVal [1,0,0,0,1,1,0,1],PolyVal [0,0,1,1,1,0,1,1],PolyVal [1,0,0,1,1,0,1,0]]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_p8(vcreate_p8(UINT64_C(0x71b3e6753e2e8ba1)),
                         vcreate_p8(UINT64_C(0xe51ffe1f6dffd5ea)));
      arg2 = vcombine_p8(vcreate_p8(UINT64_C(0x64055fc1b3d55d23)),
                         vcreate_p8(UINT64_C(0x59dcb179a0cf805f)));
      clear_neon_saturated();
      //  Expect: "result" = ffffffffffffffffffffffffffffffff
      result = vtstq_p8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 0);
         exp = UINT64_C(0xffffffffffffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 1);
         exp = UINT64_C(0xffffffffffffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_550() {

{
   {
      poly16x8_t arg1;
      poly16x8_t arg2;
      uint16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"tst\", fnname = \"vtstq_p16\", rettype = \"uint16x8_t\", argtypes = \"[poly16x8_t,poly16x8_t]\", vals = [VectorVal [PolyVal [0,1,0,0,1,1,0,1,1,0,0,0,1,0,0,0],PolyVal [1,1,0,0,1,1,1,0,0,0,1,0,0,0,1,0],PolyVal [1,0,1,0,1,1,1,1,0,1,0,1,0,1,1,1],PolyVal [0,0,0,0,0,0,1,0,1,1,1,1,1,0,0,0],PolyVal [1,0,0,1,1,0,0,0,1,0,1,0,0,1,0,0],PolyVal [0,0,0,1,0,1,0,0,1,1,0,0,1,0,0,1],PolyVal [0,1,1,0,1,0,0,0,0,0,1,0,1,0,1,0],PolyVal [1,0,0,0,0,0,1,1,1,0,1,0,1,1,0,1]],VectorVal [PolyVal [1,1,0,0,0,1,0,0,1,1,1,0,1,1,1,0],PolyVal [0,0,0,1,0,0,0,0,1,0,1,0,1,1,1,0],PolyVal [0,1,0,0,0,1,0,0,1,1,1,0,1,1,0,1],PolyVal [0,1,0,1,0,1,0,1,0,1,1,1,0,1,1,1],PolyVal [0,0,0,0,1,1,0,1,0,0,1,0,1,0,1,1],PolyVal [1,1,1,0,0,0,1,1,0,1,0,0,0,1,0,1],PolyVal [0,0,1,1,1,0,0,0,1,1,0,1,1,0,0,0],PolyVal [1,1,1,1,1,1,1,0,0,0,1,0,1,1,0,0]]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_p16(vcreate_p16(UINT64_C(0x1f40eaf5447311b2)),
                          vcreate_p16(UINT64_C(0xb5c1541693282519)));
      arg2 = vcombine_p16(vcreate_p16(UINT64_C(0xeeaab72275087723)),
                          vcreate_p16(UINT64_C(0x347f1b1ca2c7d4b0)));
      clear_neon_saturated();
      //  Expect: "result" = ffffffffffffffffffffffffffffffff
      result = vtstq_p16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 0);
         exp = UINT64_C(0xffffffffffffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 1);
         exp = UINT64_C(0xffffffffffffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_551() {

{
   {
      int64_t arg1;
      int64_t arg2;
      uint64_t result;
      char* str1 = "ReproInfo2 {semantics = \"tst\", fnname = \"vtstd_s64\", rettype = \"uint64_t\", argtypes = \"[int64_t,int64_t]\", vals = [IntegerVal (-9223231301513909752),IntegerVal (-140733193453568)], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = INT64_C(-9223231301513909752);
      arg2 = INT64_C(-140733193453568);
      clear_neon_saturated();
      //  Expect: "result" = ffffffffffffffff
      result = vtstd_s64(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = UINT64_C(0xffffffffffffffff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_552() {

{
   {
      uint64_t arg1;
      uint64_t arg2;
      uint64_t result;
      char* str1 = "ReproInfo2 {semantics = \"tst\", fnname = \"vtstd_u64\", rettype = \"uint64_t\", argtypes = \"[uint64_t,uint64_t]\", vals = [IntegerVal 9223090561878097920,IntegerVal 1360560127], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = UINT64_C(0x7fff000000008000);
      arg2 = UINT64_C(0x0000000051187fff);
      clear_neon_saturated();
      //  Expect: "result" = 0000000000000000
      result = vtstd_u64(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = 0;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_553() {

{
   {
      int8x8_t arg1;
      uint8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"ceqz\", fnname = \"vceqz_s8\", rettype = \"uint8x8_t\", argtypes = \"[int8x8_t]\", vals = [VectorVal [IntegerVal (-1),IntegerVal 127,IntegerVal 29,IntegerVal (-52),IntegerVal 127,IntegerVal 127,IntegerVal 101,IntegerVal (-128)]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s8(UINT64_C(0x80657f7fcc1d7fff));
      clear_neon_saturated();
      //  Expect: "result" = 0000000000000000
      result = vceqz_s8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u8(result), 0);
      exp = 0;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_554() {

{
   {
      int16x4_t arg1;
      uint16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"ceqz\", fnname = \"vceqz_s16\", rettype = \"uint16x4_t\", argtypes = \"[int16x4_t]\", vals = [VectorVal [IntegerVal (-32768),IntegerVal 32767,IntegerVal (-1),IntegerVal (-32768)]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s16(UINT64_C(0x8000ffff7fff8000));
      clear_neon_saturated();
      //  Expect: "result" = 0000000000000000
      result = vceqz_s16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u16(result), 0);
      exp = 0;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_555() {

{
   {
      int32x2_t arg1;
      uint32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"ceqz\", fnname = \"vceqz_s32\", rettype = \"uint32x2_t\", argtypes = \"[int32x2_t]\", vals = [VectorVal [IntegerVal (-2147450881),IntegerVal 41286]], start_saturated = True}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s32(UINT64_C(0x0000a14680007fff));
      set_neon_saturated();
      //  Expect: "result" = 0000000000000000
      result = vceqz_s32(arg1);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u32(result), 0);
      exp = 0;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_556() {

{
   {
      uint8x8_t arg1;
      uint8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"ceqz\", fnname = \"vceqz_u8\", rettype = \"uint8x8_t\", argtypes = \"[uint8x8_t]\", vals = [VectorVal [IntegerVal 0,IntegerVal 67,IntegerVal 127,IntegerVal 0,IntegerVal 127,IntegerVal 128,IntegerVal 0,IntegerVal 96]], start_saturated = True}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u8(UINT64_C(0x6000807f007f4300));
      set_neon_saturated();
      //  Expect: "result" = 00ff0000ff0000ff
      result = vceqz_u8(arg1);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u8(result), 0);
      exp = UINT64_C(0x00ff0000ff0000ff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_557() {

{
   {
      uint16x4_t arg1;
      uint16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"ceqz\", fnname = \"vceqz_u16\", rettype = \"uint16x4_t\", argtypes = \"[uint16x4_t]\", vals = [VectorVal [IntegerVal 32768,IntegerVal 32768,IntegerVal 32767,IntegerVal 30330]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u16(UINT64_C(0x767a7fff80008000));
      clear_neon_saturated();
      //  Expect: "result" = 0000000000000000
      result = vceqz_u16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u16(result), 0);
      exp = 0;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_558() {

{
   {
      uint32x2_t arg1;
      uint32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"ceqz\", fnname = \"vceqz_u32\", rettype = \"uint32x2_t\", argtypes = \"[uint32x2_t]\", vals = [VectorVal [IntegerVal 2147450879,IntegerVal 3213230080]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u32(UINT64_C(0xbf8600007fff7fff));
      clear_neon_saturated();
      //  Expect: "result" = 0000000000000000
      result = vceqz_u32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u32(result), 0);
      exp = 0;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_559() {

{
   {
      float32x2_t arg1;
      uint32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"ceqz\", fnname = \"vceqz_f32\", rettype = \"uint32x2_t\", argtypes = \"[float32x2_t]\", vals = [VectorVal [FloatVal 0.3003637194633484,FloatVal 0.6857448816299438]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_f32(UINT64_C(0x3f2f8cfa3e99c946));
      clear_neon_saturated();
      //  Expect: "result" = 0000000000000000
      result = vceqz_f32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u32(result), 0);
      exp = 0;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_560() {

{
   {
      poly8x8_t arg1;
      uint8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"ceqz\", fnname = \"vceqz_p8\", rettype = \"uint8x8_t\", argtypes = \"[poly8x8_t]\", vals = [VectorVal [PolyVal [0,1,1,1,0,1,0,1],PolyVal [1,1,1,0,0,0,0,0],PolyVal [1,0,0,1,1,1,0,1],PolyVal [1,0,0,1,0,1,0,0],PolyVal [0,0,0,1,1,0,0,0],PolyVal [1,1,1,0,1,0,1,0],PolyVal [0,1,1,0,0,0,0,1],PolyVal [0,0,0,1,0,1,1,1]]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_p8(UINT64_C(0xe886571829b907ae));
      clear_neon_saturated();
      //  Expect: "result" = 0000000000000000
      result = vceqz_p8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u8(result), 0);
      exp = 0;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_561() {

{
   {
      int8x16_t arg1;
      uint8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"ceqz\", fnname = \"vceqzq_s8\", rettype = \"uint8x16_t\", argtypes = \"[int8x16_t]\", vals = [VectorVal [IntegerVal 0,IntegerVal (-128),IntegerVal 127,IntegerVal 0,IntegerVal (-1),IntegerVal (-1),IntegerVal (-128),IntegerVal 0,IntegerVal 18,IntegerVal (-1),IntegerVal (-1),IntegerVal (-118),IntegerVal (-1),IntegerVal 78,IntegerVal 36,IntegerVal 127]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s8(vcreate_s8(UINT64_C(0x0080ffff007f8000)),
                         vcreate_s8(UINT64_C(0x7f244eff8affff12)));
      clear_neon_saturated();
      //  Expect: "result" = 0000000000000000ff000000ff0000ff
      result = vceqzq_s8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 0);
         exp = UINT64_C(0xff000000ff0000ff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 1);
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_562() {

{
   {
      int16x8_t arg1;
      uint16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"ceqz\", fnname = \"vceqzq_s16\", rettype = \"uint16x8_t\", argtypes = \"[int16x8_t]\", vals = [VectorVal [IntegerVal 0,IntegerVal 0,IntegerVal (-1),IntegerVal (-9760),IntegerVal (-32768),IntegerVal (-32768),IntegerVal 23792,IntegerVal (-1)]], start_saturated = True}";
      int reported = 0;
      arg1 = vcombine_s16(vcreate_s16(UINT64_C(0xd9e0ffff00000000)),
                          vcreate_s16(UINT64_C(0xffff5cf080008000)));
      set_neon_saturated();
      //  Expect: "result" = 000000000000000000000000ffffffff
      result = vceqzq_s16(arg1);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 0);
         exp = UINT64_C(0x00000000ffffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 1);
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_563() {

{
   {
      int32x4_t arg1;
      uint32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"ceqz\", fnname = \"vceqzq_s32\", rettype = \"uint32x4_t\", argtypes = \"[int32x4_t]\", vals = [VectorVal [IntegerVal (-32769),IntegerVal (-32769),IntegerVal (-2147436175),IntegerVal (-2147418113)]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s32(vcreate_s32(UINT64_C(0xffff7fffffff7fff)),
                          vcreate_s32(UINT64_C(0x8000ffff8000b971)));
      clear_neon_saturated();
      //  Expect: "result" = 00000000000000000000000000000000
      result = vceqzq_s32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 0);
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 1);
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_564() {

{
   {
      uint8x16_t arg1;
      uint8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"ceqz\", fnname = \"vceqzq_u8\", rettype = \"uint8x16_t\", argtypes = \"[uint8x16_t]\", vals = [VectorVal [IntegerVal 127,IntegerVal 127,IntegerVal 198,IntegerVal 0,IntegerVal 0,IntegerVal 128,IntegerVal 151,IntegerVal 255,IntegerVal 11,IntegerVal 128,IntegerVal 127,IntegerVal 255,IntegerVal 128,IntegerVal 116,IntegerVal 127,IntegerVal 227]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u8(vcreate_u8(UINT64_C(0xff97800000c67f7f)),
                         vcreate_u8(UINT64_C(0xe37f7480ff7f800b)));
      clear_neon_saturated();
      //  Expect: "result" = 0000000000000000000000ffff000000
      result = vceqzq_u8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 0);
         exp = UINT64_C(0x000000ffff000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 1);
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_565() {

{
   {
      uint16x8_t arg1;
      uint16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"ceqz\", fnname = \"vceqzq_u16\", rettype = \"uint16x8_t\", argtypes = \"[uint16x8_t]\", vals = [VectorVal [IntegerVal 0,IntegerVal 32767,IntegerVal 32767,IntegerVal 51167,IntegerVal 0,IntegerVal 65535,IntegerVal 32767,IntegerVal 0]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u16(vcreate_u16(UINT64_C(0xc7df7fff7fff0000)),
                          vcreate_u16(UINT64_C(0x00007fffffff0000)));
      clear_neon_saturated();
      //  Expect: "result" = ffff00000000ffff000000000000ffff
      result = vceqzq_u16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 0);
         exp = UINT64_C(0x000000000000ffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 1);
         exp = UINT64_C(0xffff00000000ffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_566() {

{
   {
      uint32x4_t arg1;
      uint32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"ceqz\", fnname = \"vceqzq_u32\", rettype = \"uint32x4_t\", argtypes = \"[uint32x4_t]\", vals = [VectorVal [IntegerVal 2147516416,IntegerVal 2147516416,IntegerVal 2147418112,IntegerVal 2147483648]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u32(vcreate_u32(UINT64_C(0x8000800080008000)),
                          vcreate_u32(UINT64_C(0x800000007fff0000)));
      clear_neon_saturated();
      //  Expect: "result" = 00000000000000000000000000000000
      result = vceqzq_u32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 0);
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 1);
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_567() {

{
   {
      float32x4_t arg1;
      uint32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"ceqz\", fnname = \"vceqzq_f32\", rettype = \"uint32x4_t\", argtypes = \"[float32x4_t]\", vals = [VectorVal [FloatVal 0.40799158811569214,FloatVal 4.955345392227173e-2,FloatVal 0.1399112343788147,FloatVal 0.36323922872543335]], start_saturated = True}";
      int reported = 0;
      arg1 = vcombine_f32(vcreate_f32(UINT64_C(0x3d4af8903ed0e446)),
                          vcreate_f32(UINT64_C(0x3eb9fa7e3e0f44e4)));
      set_neon_saturated();
      //  Expect: "result" = 00000000000000000000000000000000
      result = vceqzq_f32(arg1);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 0);
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 1);
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_568() {

{
   {
      poly8x16_t arg1;
      uint8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"ceqz\", fnname = \"vceqzq_p8\", rettype = \"uint8x16_t\", argtypes = \"[poly8x16_t]\", vals = [VectorVal [PolyVal [0,1,1,1,0,1,0,1],PolyVal [0,0,0,0,0,1,1,1],PolyVal [1,0,0,0,0,0,0,1],PolyVal [1,0,1,1,0,1,1,0],PolyVal [1,1,0,1,1,0,1,1],PolyVal [1,1,0,1,0,0,0,0],PolyVal [0,1,1,0,0,1,0,0],PolyVal [0,0,0,0,1,0,0,1],PolyVal [1,0,1,1,1,0,0,0],PolyVal [0,1,0,1,0,1,0,1],PolyVal [1,1,1,0,1,1,0,1],PolyVal [0,1,1,0,0,0,0,0],PolyVal [0,0,0,0,1,0,1,0],PolyVal [0,1,1,1,0,1,0,1],PolyVal [0,1,0,1,1,0,0,1],PolyVal [1,1,1,1,0,0,0,0]]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_p8(vcreate_p8(UINT64_C(0x90260bdb6d81e0ae)),
                         vcreate_p8(UINT64_C(0x0f9aae5006b7aa1d)));
      clear_neon_saturated();
      //  Expect: "result" = 00000000000000000000000000000000
      result = vceqzq_p8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 0);
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 1);
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_569() {

{
   {
      int64x1_t arg1;
      uint64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"ceqz\", fnname = \"vceqz_s64\", rettype = \"uint64x1_t\", argtypes = \"[int64x1_t]\", vals = [VectorVal [IntegerVal (-2514415966956290049)]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s64(UINT64_C(0xdd1affffffffffff));
      clear_neon_saturated();
      //  Expect: "result" = 0000000000000000
      result = vceqz_s64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(result, 0);
      exp = 0;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_570() {

{
   {
      uint64x1_t arg1;
      uint64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"ceqz\", fnname = \"vceqz_u64\", rettype = \"uint64x1_t\", argtypes = \"[uint64x1_t]\", vals = [VectorVal [IntegerVal 110318382514176]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u64(UINT64_C(0x0000645580008000));
      clear_neon_saturated();
      //  Expect: "result" = 0000000000000000
      result = vceqz_u64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(result, 0);
      exp = 0;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_571() {

{
   {
      float64x1_t arg1;
      uint64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"ceqz\", fnname = \"vceqz_f64\", rettype = \"uint64x1_t\", argtypes = \"[float64x1_t]\", vals = [VectorVal [FloatVal 0.9261822961431372]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_f64(UINT64_C(0x3feda3490e0234ee));
      clear_neon_saturated();
      //  Expect: "result" = 0000000000000000
      result = vceqz_f64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(result, 0);
      exp = 0;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_572() {

{
   {
      int64x2_t arg1;
      uint64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"ceqz\", fnname = \"vceqzq_s64\", rettype = \"uint64x2_t\", argtypes = \"[int64x2_t]\", vals = [VectorVal [IntegerVal (-140735340827472),IntegerVal (-140737488322561)]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s64(vcreate_s64(UINT64_C(0xffff80008000acb0)),
                          vcreate_s64(UINT64_C(0xffff800000007fff)));
      clear_neon_saturated();
      //  Expect: "result" = 00000000000000000000000000000000
      result = vceqzq_s64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 0);
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 1);
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_573() {

{
   {
      uint64x2_t arg1;
      uint64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"ceqz\", fnname = \"vceqzq_u64\", rettype = \"uint64x2_t\", argtypes = \"[uint64x2_t]\", vals = [VectorVal [IntegerVal 9223512776490647552,IntegerVal 4337388655770337280]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u64(vcreate_u64(UINT64_C(0x8000800080008000)),
                          vcreate_u64(UINT64_C(0x3c31800080000000)));
      clear_neon_saturated();
      //  Expect: "result" = 00000000000000000000000000000000
      result = vceqzq_u64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 0);
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 1);
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_574() {

{
   {
      float64x2_t arg1;
      uint64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"ceqz\", fnname = \"vceqzq_f64\", rettype = \"uint64x2_t\", argtypes = \"[float64x2_t]\", vals = [VectorVal [FloatVal 0.5582853077023004,FloatVal 0.30742480100418124]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_f64(vcreate_f64(UINT64_C(0x3fe1dd79264d65ce)),
                          vcreate_f64(UINT64_C(0x3fd3acd91292b47e)));
      clear_neon_saturated();
      //  Expect: "result" = 00000000000000000000000000000000
      result = vceqzq_f64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 0);
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 1);
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_575() {

{
   {
      int64_t arg1;
      uint64_t result;
      char* str1 = "ReproInfo2 {semantics = \"ceqz\", fnname = \"vceqzd_s64\", rettype = \"uint64_t\", argtypes = \"[int64_t]\", vals = [IntegerVal (-9223306708254720001)], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = INT64_C(-9223306708254720001);
      clear_neon_saturated();
      //  Expect: "result" = 0000000000000000
      result = vceqzd_s64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = 0;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_576() {

{
   {
      uint64_t arg1;
      uint64_t result;
      char* str1 = "ReproInfo2 {semantics = \"ceqz\", fnname = \"vceqzd_u64\", rettype = \"uint64_t\", argtypes = \"[uint64_t]\", vals = [IntegerVal 9223422056043937791], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = UINT64_C(0x80002d7e00007fff);
      clear_neon_saturated();
      //  Expect: "result" = 0000000000000000
      result = vceqzd_u64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = 0;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_577() {

{
   {
      float32_t arg1;
      uint32_t result;
      char* str1 = "ReproInfo2 {semantics = \"ceqz\", fnname = \"vceqzs_f32\", rettype = \"uint32_t\", argtypes = \"[float32_t]\", vals = [FloatVal 0.9739976525306702], start_saturated = False}";
      int reported = 0;
      uint32_t got;
      uint32_t exp;
      arg1 = ((float32_t) 0.9739976525306702);
      clear_neon_saturated();
      //  Expect: "result" = 00000000
      result = vceqzs_f32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = 0;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIu32 " Got: %" PRIu32 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_578() {

{
   {
      float64_t arg1;
      uint64_t result;
      char* str1 = "ReproInfo2 {semantics = \"ceqz\", fnname = \"vceqzd_f64\", rettype = \"uint64_t\", argtypes = \"[float64_t]\", vals = [FloatVal 0.21121090308944557], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = 0.21121090308944557;
      clear_neon_saturated();
      //  Expect: "result" = 0000000000000000
      result = vceqzd_f64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = 0;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_579() {

{
   {
      int8x8_t arg1;
      uint8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"cgtz\", fnname = \"vcgtz_s8\", rettype = \"uint8x8_t\", argtypes = \"[int8x8_t]\", vals = [VectorVal [IntegerVal (-1),IntegerVal (-28),IntegerVal (-1),IntegerVal 0,IntegerVal (-1),IntegerVal 0,IntegerVal (-1),IntegerVal (-128)]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s8(UINT64_C(0x80ff00ff00ffe4ff));
      clear_neon_saturated();
      //  Expect: "result" = 0000000000000000
      result = vcgtz_s8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u8(result), 0);
      exp = 0;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_580() {

{
   {
      int16x4_t arg1;
      uint16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"cgtz\", fnname = \"vcgtz_s16\", rettype = \"uint16x4_t\", argtypes = \"[int16x4_t]\", vals = [VectorVal [IntegerVal 0,IntegerVal 11180,IntegerVal (-1),IntegerVal 0]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s16(UINT64_C(0x0000ffff2bac0000));
      clear_neon_saturated();
      //  Expect: "result" = 00000000ffff0000
      result = vcgtz_s16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u16(result), 0);
      exp = UINT64_C(0x00000000ffff0000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_581() {

{
   {
      int32x2_t arg1;
      uint32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"cgtz\", fnname = \"vcgtz_s32\", rettype = \"uint32x2_t\", argtypes = \"[int32x2_t]\", vals = [VectorVal [IntegerVal (-2087341909),IntegerVal 2147450880]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s32(UINT64_C(0x7fff80008395b0ab));
      clear_neon_saturated();
      //  Expect: "result" = ffffffff00000000
      result = vcgtz_s32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u32(result), 0);
      exp = UINT64_C(0xffffffff00000000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_582() {

{
   {
      float32x2_t arg1;
      uint32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"cgtz\", fnname = \"vcgtz_f32\", rettype = \"uint32x2_t\", argtypes = \"[float32x2_t]\", vals = [VectorVal [FloatVal 0.6353201866149902,FloatVal 0.43587422370910645]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_f32(UINT64_C(0x3edf2ae83f22a458));
      clear_neon_saturated();
      //  Expect: "result" = ffffffffffffffff
      result = vcgtz_f32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u32(result), 0);
      exp = UINT64_C(0xffffffffffffffff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_583() {

{
   {
      int8x16_t arg1;
      uint8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"cgtz\", fnname = \"vcgtzq_s8\", rettype = \"uint8x16_t\", argtypes = \"[int8x16_t]\", vals = [VectorVal [IntegerVal (-1),IntegerVal (-128),IntegerVal 31,IntegerVal (-128),IntegerVal 0,IntegerVal (-1),IntegerVal 34,IntegerVal (-1),IntegerVal (-1),IntegerVal (-128),IntegerVal 127,IntegerVal (-128),IntegerVal 127,IntegerVal (-1),IntegerVal (-1),IntegerVal 127]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s8(vcreate_s8(UINT64_C(0xff22ff00801f80ff)),
                         vcreate_s8(UINT64_C(0x7fffff7f807f80ff)));
      clear_neon_saturated();
      //  Expect: "result" = ff0000ff00ff000000ff000000ff0000
      result = vcgtzq_s8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 0);
         exp = UINT64_C(0x00ff000000ff0000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 1);
         exp = UINT64_C(0xff0000ff00ff0000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_584() {

{
   {
      int16x8_t arg1;
      uint16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"cgtz\", fnname = \"vcgtzq_s16\", rettype = \"uint16x8_t\", argtypes = \"[int16x8_t]\", vals = [VectorVal [IntegerVal 32767,IntegerVal 24219,IntegerVal (-13852),IntegerVal (-1),IntegerVal (-32768),IntegerVal (-1),IntegerVal (-29146),IntegerVal (-1)]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s16(vcreate_s16(UINT64_C(0xffffc9e45e9b7fff)),
                          vcreate_s16(UINT64_C(0xffff8e26ffff8000)));
      clear_neon_saturated();
      //  Expect: "result" = 000000000000000000000000ffffffff
      result = vcgtzq_s16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 0);
         exp = UINT64_C(0x00000000ffffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 1);
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_585() {

{
   {
      int32x4_t arg1;
      uint32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"cgtz\", fnname = \"vcgtzq_s32\", rettype = \"uint32x4_t\", argtypes = \"[int32x4_t]\", vals = [VectorVal [IntegerVal (-1),IntegerVal (-2147418113),IntegerVal 2147418112,IntegerVal 2147483647]], start_saturated = True}";
      int reported = 0;
      arg1 = vcombine_s32(vcreate_s32(UINT64_C(0x8000ffffffffffff)),
                          vcreate_s32(UINT64_C(0x7fffffff7fff0000)));
      set_neon_saturated();
      //  Expect: "result" = ffffffffffffffff0000000000000000
      result = vcgtzq_s32(arg1);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 0);
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 1);
         exp = UINT64_C(0xffffffffffffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_586() {

{
   {
      float32x4_t arg1;
      uint32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"cgtz\", fnname = \"vcgtzq_f32\", rettype = \"uint32x4_t\", argtypes = \"[float32x4_t]\", vals = [VectorVal [FloatVal 0.9398011565208435,FloatVal 0.43265461921691895,FloatVal 0.9925274848937988,FloatVal 0.5871894359588623]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_f32(vcreate_f32(UINT64_C(0x3edd84e83f7096cf)),
                          vcreate_f32(UINT64_C(0x3f16520c3f7e1648)));
      clear_neon_saturated();
      //  Expect: "result" = ffffffffffffffffffffffffffffffff
      result = vcgtzq_f32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 0);
         exp = UINT64_C(0xffffffffffffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 1);
         exp = UINT64_C(0xffffffffffffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_587() {

{
   {
      int64x1_t arg1;
      uint64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"cgtz\", fnname = \"vcgtz_s64\", rettype = \"uint64x1_t\", argtypes = \"[int64x1_t]\", vals = [VectorVal [IntegerVal 9223090564025516031]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s64(UINT64_C(0x7fff00007fff7fff));
      clear_neon_saturated();
      //  Expect: "result" = ffffffffffffffff
      result = vcgtz_s64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(result, 0);
      exp = UINT64_C(0xffffffffffffffff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_588() {

{
   {
      float64x1_t arg1;
      uint64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"cgtz\", fnname = \"vcgtz_f64\", rettype = \"uint64x1_t\", argtypes = \"[float64x1_t]\", vals = [VectorVal [FloatVal 0.9981628533616306]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_f64(UINT64_C(0x3feff0f33968a5dd));
      clear_neon_saturated();
      //  Expect: "result" = ffffffffffffffff
      result = vcgtz_f64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(result, 0);
      exp = UINT64_C(0xffffffffffffffff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_589() {

{
   {
      int64x2_t arg1;
      uint64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"cgtz\", fnname = \"vcgtzq_s64\", rettype = \"uint64x2_t\", argtypes = \"[int64x2_t]\", vals = [VectorVal [IntegerVal 281472829227008,IntegerVal (-4612389708016648193)]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s64(vcreate_s64(UINT64_C(0x0000ffff80000000)),
                          vcreate_s64(UINT64_C(0xbffd7fff7fffffff)));
      clear_neon_saturated();
      //  Expect: "result" = 0000000000000000ffffffffffffffff
      result = vcgtzq_s64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 0);
         exp = UINT64_C(0xffffffffffffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 1);
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_590() {

{
   {
      float64x2_t arg1;
      uint64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"cgtz\", fnname = \"vcgtzq_f64\", rettype = \"uint64x2_t\", argtypes = \"[float64x2_t]\", vals = [VectorVal [FloatVal 0.7552487440573181,FloatVal 0.4520778208989702]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_f64(vcreate_f64(UINT64_C(0x3fe82aff6a0247ba)),
                          vcreate_f64(UINT64_C(0x3fdceed7d0008370)));
      clear_neon_saturated();
      //  Expect: "result" = ffffffffffffffffffffffffffffffff
      result = vcgtzq_f64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 0);
         exp = UINT64_C(0xffffffffffffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 1);
         exp = UINT64_C(0xffffffffffffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_591() {

{
   {
      int64_t arg1;
      uint64_t result;
      char* str1 = "ReproInfo2 {semantics = \"cgtz\", fnname = \"vcgtzd_s64\", rettype = \"uint64_t\", argtypes = \"[int64_t]\", vals = [IntegerVal (-36185)], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = INT64_C(-36185);
      clear_neon_saturated();
      //  Expect: "result" = 0000000000000000
      result = vcgtzd_s64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = 0;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_592() {

{
   {
      float32_t arg1;
      uint32_t result;
      char* str1 = "ReproInfo2 {semantics = \"cgtz\", fnname = \"vcgtzs_f32\", rettype = \"uint32_t\", argtypes = \"[float32_t]\", vals = [FloatVal 0.3822554349899292], start_saturated = False}";
      int reported = 0;
      uint32_t got;
      uint32_t exp;
      arg1 = ((float32_t) 0.3822554349899292);
      clear_neon_saturated();
      //  Expect: "result" = ffffffff
      result = vcgtzs_f32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = 4294967295U;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIu32 " Got: %" PRIu32 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_593() {

{
   {
      float64_t arg1;
      uint64_t result;
      char* str1 = "ReproInfo2 {semantics = \"cgtz\", fnname = \"vcgtzd_f64\", rettype = \"uint64_t\", argtypes = \"[float64_t]\", vals = [FloatVal 0.8651276495456126], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = 0.8651276495456126;
      clear_neon_saturated();
      //  Expect: "result" = ffffffffffffffff
      result = vcgtzd_f64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = UINT64_C(0xffffffffffffffff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_594() {

{
   {
      int8x8_t arg1;
      uint8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"cgez\", fnname = \"vcgez_s8\", rettype = \"uint8x8_t\", argtypes = \"[int8x8_t]\", vals = [VectorVal [IntegerVal (-128),IntegerVal (-57),IntegerVal (-128),IntegerVal 77,IntegerVal (-1),IntegerVal 127,IntegerVal (-1),IntegerVal (-1)]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s8(UINT64_C(0xffff7fff4d80c780));
      clear_neon_saturated();
      //  Expect: "result" = 0000ff00ff000000
      result = vcgez_s8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u8(result), 0);
      exp = UINT64_C(0x0000ff00ff000000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_595() {

{
   {
      int16x4_t arg1;
      uint16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"cgez\", fnname = \"vcgez_s16\", rettype = \"uint16x4_t\", argtypes = \"[int16x4_t]\", vals = [VectorVal [IntegerVal 32767,IntegerVal 32767,IntegerVal (-14897),IntegerVal 0]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s16(UINT64_C(0x0000c5cf7fff7fff));
      clear_neon_saturated();
      //  Expect: "result" = ffff0000ffffffff
      result = vcgez_s16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u16(result), 0);
      exp = UINT64_C(0xffff0000ffffffff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_596() {

{
   {
      int32x2_t arg1;
      uint32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"cgez\", fnname = \"vcgez_s32\", rettype = \"uint32x2_t\", argtypes = \"[int32x2_t]\", vals = [VectorVal [IntegerVal (-975056780),IntegerVal 2147418112]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s32(UINT64_C(0x7fff0000c5e1d074));
      clear_neon_saturated();
      //  Expect: "result" = ffffffff00000000
      result = vcgez_s32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u32(result), 0);
      exp = UINT64_C(0xffffffff00000000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_597() {

{
   {
      float32x2_t arg1;
      uint32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"cgez\", fnname = \"vcgez_f32\", rettype = \"uint32x2_t\", argtypes = \"[float32x2_t]\", vals = [VectorVal [FloatVal 0.23201924562454224,FloatVal 0.7345443964004517]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_f32(UINT64_C(0x3f3c0b1a3e6d9674));
      clear_neon_saturated();
      //  Expect: "result" = ffffffffffffffff
      result = vcgez_f32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u32(result), 0);
      exp = UINT64_C(0xffffffffffffffff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_598() {

{
   {
      int8x16_t arg1;
      uint8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"cgez\", fnname = \"vcgezq_s8\", rettype = \"uint8x16_t\", argtypes = \"[int8x16_t]\", vals = [VectorVal [IntegerVal (-1),IntegerVal (-1),IntegerVal 0,IntegerVal (-19),IntegerVal (-123),IntegerVal 127,IntegerVal (-128),IntegerVal 127,IntegerVal 0,IntegerVal 0,IntegerVal 127,IntegerVal (-1),IntegerVal 76,IntegerVal (-1),IntegerVal 0,IntegerVal (-128)]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s8(vcreate_s8(UINT64_C(0x7f807f85ed00ffff)),
                         vcreate_s8(UINT64_C(0x8000ff4cff7f0000)));
      clear_neon_saturated();
      //  Expect: "result" = 00ff00ff00ffffffff00ff0000ff0000
      result = vcgezq_s8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 0);
         exp = UINT64_C(0xff00ff0000ff0000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 1);
         exp = UINT64_C(0x00ff00ff00ffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_599() {

{
   {
      int16x8_t arg1;
      uint16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"cgez\", fnname = \"vcgezq_s16\", rettype = \"uint16x8_t\", argtypes = \"[int16x8_t]\", vals = [VectorVal [IntegerVal 0,IntegerVal 32767,IntegerVal 32767,IntegerVal (-32768),IntegerVal 0,IntegerVal 32767,IntegerVal 32767,IntegerVal 0]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s16(vcreate_s16(UINT64_C(0x80007fff7fff0000)),
                          vcreate_s16(UINT64_C(0x00007fff7fff0000)));
      clear_neon_saturated();
      //  Expect: "result" = ffffffffffffffff0000ffffffffffff
      result = vcgezq_s16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 0);
         exp = UINT64_C(0x0000ffffffffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 1);
         exp = UINT64_C(0xffffffffffffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_600() {

{
   {
      int32x4_t arg1;
      uint32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"cgez\", fnname = \"vcgezq_s32\", rettype = \"uint32x4_t\", argtypes = \"[int32x4_t]\", vals = [VectorVal [IntegerVal (-293371905),IntegerVal 0,IntegerVal 2147433514,IntegerVal (-1359085568)]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s32(vcreate_s32(UINT64_C(0x00000000ee837fff)),
                          vcreate_s32(UINT64_C(0xaefe00007fff3c2a)));
      clear_neon_saturated();
      //  Expect: "result" = 00000000ffffffffffffffff00000000
      result = vcgezq_s32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 0);
         exp = UINT64_C(0xffffffff00000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 1);
         exp = UINT64_C(0x00000000ffffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_601() {

{
   {
      float32x4_t arg1;
      uint32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"cgez\", fnname = \"vcgezq_f32\", rettype = \"uint32x4_t\", argtypes = \"[float32x4_t]\", vals = [VectorVal [FloatVal 4.6911418437957764e-2,FloatVal 0.11471593379974365,FloatVal 0.671816885471344,FloatVal 0.7855742573738098]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_f32(vcreate_f32(UINT64_C(0x3deaf0303d402630)),
                          vcreate_f32(UINT64_C(0x3f491b653f2bfc31)));
      clear_neon_saturated();
      //  Expect: "result" = ffffffffffffffffffffffffffffffff
      result = vcgezq_f32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 0);
         exp = UINT64_C(0xffffffffffffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 1);
         exp = UINT64_C(0xffffffffffffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_602() {

{
   {
      int64x1_t arg1;
      uint64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"cgez\", fnname = \"vcgez_s64\", rettype = \"uint64x1_t\", argtypes = \"[int64x1_t]\", vals = [VectorVal [IntegerVal 2593369697923661824]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s64(UINT64_C(0x23fd800000008000));
      clear_neon_saturated();
      //  Expect: "result" = ffffffffffffffff
      result = vcgez_s64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(result, 0);
      exp = UINT64_C(0xffffffffffffffff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_603() {

{
   {
      float64x1_t arg1;
      uint64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"cgez\", fnname = \"vcgez_f64\", rettype = \"uint64x1_t\", argtypes = \"[float64x1_t]\", vals = [VectorVal [FloatVal 0.1678869881631948]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_f64(UINT64_C(0x3fc57d5221cadcb8));
      clear_neon_saturated();
      //  Expect: "result" = ffffffffffffffff
      result = vcgez_f64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(result, 0);
      exp = UINT64_C(0xffffffffffffffff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_604() {

{
   {
      int64x2_t arg1;
      uint64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"cgez\", fnname = \"vcgezq_s64\", rettype = \"uint64x2_t\", argtypes = \"[int64x2_t]\", vals = [VectorVal [IntegerVal 9223372032559856503,IntegerVal 9223341203919351518]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s64(vcreate_s64(UINT64_C(0x7fffffff0000bb77)),
                          vcreate_s64(UINT64_C(0x7fffe3f525d62ede)));
      clear_neon_saturated();
      //  Expect: "result" = ffffffffffffffffffffffffffffffff
      result = vcgezq_s64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 0);
         exp = UINT64_C(0xffffffffffffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 1);
         exp = UINT64_C(0xffffffffffffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_605() {

{
   {
      float64x2_t arg1;
      uint64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"cgez\", fnname = \"vcgezq_f64\", rettype = \"uint64x2_t\", argtypes = \"[float64x2_t]\", vals = [VectorVal [FloatVal 0.6086284150968801,FloatVal 0.550762472841546]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_f64(vcreate_f64(UINT64_C(0x3fe379e24c483cba)),
                          vcreate_f64(UINT64_C(0x3fe19fd89f16fe2f)));
      clear_neon_saturated();
      //  Expect: "result" = ffffffffffffffffffffffffffffffff
      result = vcgezq_f64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 0);
         exp = UINT64_C(0xffffffffffffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 1);
         exp = UINT64_C(0xffffffffffffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_606() {

{
   {
      int64_t arg1;
      uint64_t result;
      char* str1 = "ReproInfo2 {semantics = \"cgez\", fnname = \"vcgezd_s64\", rettype = \"uint64_t\", argtypes = \"[int64_t]\", vals = [IntegerVal 9223370278207881215], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = INT64_C(9223370278207881215);
      clear_neon_saturated();
      //  Expect: "result" = ffffffffffffffff
      result = vcgezd_s64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = UINT64_C(0xffffffffffffffff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_607() {

{
   {
      float32_t arg1;
      uint32_t result;
      char* str1 = "ReproInfo2 {semantics = \"cgez\", fnname = \"vcgezs_f32\", rettype = \"uint32_t\", argtypes = \"[float32_t]\", vals = [FloatVal 0.5407934188842773], start_saturated = False}";
      int reported = 0;
      uint32_t got;
      uint32_t exp;
      arg1 = ((float32_t) 0.5407934188842773);
      clear_neon_saturated();
      //  Expect: "result" = ffffffff
      result = vcgezs_f32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = 4294967295U;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIu32 " Got: %" PRIu32 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_608() {

{
   {
      float64_t arg1;
      uint64_t result;
      char* str1 = "ReproInfo2 {semantics = \"cgez\", fnname = \"vcgezd_f64\", rettype = \"uint64_t\", argtypes = \"[float64_t]\", vals = [FloatVal 0.3275359400346516], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = 0.3275359400346516;
      clear_neon_saturated();
      //  Expect: "result" = ffffffffffffffff
      result = vcgezd_f64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = UINT64_C(0xffffffffffffffff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_609() {

{
   {
      int8x8_t arg1;
      uint8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"clez\", fnname = \"vclez_s8\", rettype = \"uint8x8_t\", argtypes = \"[int8x8_t]\", vals = [VectorVal [IntegerVal 0,IntegerVal 127,IntegerVal (-128),IntegerVal (-3),IntegerVal (-102),IntegerVal (-103),IntegerVal 0,IntegerVal 127]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s8(UINT64_C(0x7f00999afd807f00));
      clear_neon_saturated();
      //  Expect: "result" = 00ffffffffff00ff
      result = vclez_s8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u8(result), 0);
      exp = UINT64_C(0x00ffffffffff00ff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_610() {

{
   {
      int16x4_t arg1;
      uint16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"clez\", fnname = \"vclez_s16\", rettype = \"uint16x4_t\", argtypes = \"[int16x4_t]\", vals = [VectorVal [IntegerVal (-11710),IntegerVal 0,IntegerVal (-32768),IntegerVal (-32768)]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s16(UINT64_C(0x800080000000d242));
      clear_neon_saturated();
      //  Expect: "result" = ffffffffffffffff
      result = vclez_s16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u16(result), 0);
      exp = UINT64_C(0xffffffffffffffff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_611() {

{
   {
      int32x2_t arg1;
      uint32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"clez\", fnname = \"vclez_s32\", rettype = \"uint32x2_t\", argtypes = \"[int32x2_t]\", vals = [VectorVal [IntegerVal 2055591558,IntegerVal (-24186)]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s32(UINT64_C(0xffffa1867a85d686));
      clear_neon_saturated();
      //  Expect: "result" = ffffffff00000000
      result = vclez_s32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u32(result), 0);
      exp = UINT64_C(0xffffffff00000000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_612() {

{
   {
      float32x2_t arg1;
      uint32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"clez\", fnname = \"vclez_f32\", rettype = \"uint32x2_t\", argtypes = \"[float32x2_t]\", vals = [VectorVal [FloatVal 8.593881130218506e-2,FloatVal 0.7773053646087646]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_f32(UINT64_C(0x3f46fd7c3db000b0));
      clear_neon_saturated();
      //  Expect: "result" = 0000000000000000
      result = vclez_f32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u32(result), 0);
      exp = 0;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_613() {

{
   {
      int8x16_t arg1;
      uint8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"clez\", fnname = \"vclezq_s8\", rettype = \"uint8x16_t\", argtypes = \"[int8x16_t]\", vals = [VectorVal [IntegerVal (-1),IntegerVal 12,IntegerVal (-128),IntegerVal (-1),IntegerVal 0,IntegerVal (-1),IntegerVal 0,IntegerVal (-1),IntegerVal (-1),IntegerVal (-1),IntegerVal 127,IntegerVal 127,IntegerVal (-128),IntegerVal 127,IntegerVal 127,IntegerVal (-128)]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s8(vcreate_s8(UINT64_C(0xff00ff00ff800cff)),
                         vcreate_s8(UINT64_C(0x807f7f807f7fffff)));
      clear_neon_saturated();
      //  Expect: "result" = ff0000ff0000ffffffffffffffff00ff
      result = vclezq_s8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 0);
         exp = UINT64_C(0xffffffffffff00ff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 1);
         exp = UINT64_C(0xff0000ff0000ffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_614() {

{
   {
      int16x8_t arg1;
      uint16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"clez\", fnname = \"vclezq_s16\", rettype = \"uint16x8_t\", argtypes = \"[int16x8_t]\", vals = [VectorVal [IntegerVal 0,IntegerVal 0,IntegerVal 0,IntegerVal 32767,IntegerVal 0,IntegerVal (-30356),IntegerVal 0,IntegerVal (-15980)]], start_saturated = True}";
      int reported = 0;
      arg1 = vcombine_s16(vcreate_s16(UINT64_C(0x7fff000000000000)),
                          vcreate_s16(UINT64_C(0xc1940000896c0000)));
      set_neon_saturated();
      //  Expect: "result" = ffffffffffffffff0000ffffffffffff
      result = vclezq_s16(arg1);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 0);
         exp = UINT64_C(0x0000ffffffffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 1);
         exp = UINT64_C(0xffffffffffffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_615() {

{
   {
      int32x4_t arg1;
      uint32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"clez\", fnname = \"vclezq_s32\", rettype = \"uint32x4_t\", argtypes = \"[int32x4_t]\", vals = [VectorVal [IntegerVal (-759328500),IntegerVal 257130495,IntegerVal (-2147450880),IntegerVal (-65536)]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s32(vcreate_s32(UINT64_C(0x0f537fffd2bd910c)),
                          vcreate_s32(UINT64_C(0xffff000080008000)));
      clear_neon_saturated();
      //  Expect: "result" = ffffffffffffffff00000000ffffffff
      result = vclezq_s32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 0);
         exp = UINT64_C(0x00000000ffffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 1);
         exp = UINT64_C(0xffffffffffffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_616() {

{
   {
      float32x4_t arg1;
      uint32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"clez\", fnname = \"vclezq_f32\", rettype = \"uint32x4_t\", argtypes = \"[float32x4_t]\", vals = [VectorVal [FloatVal 0.6417778134346008,FloatVal 0.8176906108856201,FloatVal 0.29450398683547974,FloatVal 8.9851975440979e-2]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_f32(vcreate_f32(UINT64_C(0x3f51542c3f244b8d)),
                          vcreate_f32(UINT64_C(0x3db804503e96c93a)));
      clear_neon_saturated();
      //  Expect: "result" = 00000000000000000000000000000000
      result = vclezq_f32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 0);
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 1);
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_617() {

{
   {
      int64x1_t arg1;
      uint64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"clez\", fnname = \"vclez_s64\", rettype = \"uint64x1_t\", argtypes = \"[int64x1_t]\", vals = [VectorVal [IntegerVal (-140737488355328)]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s64(UINT64_C(0xffff800000000000));
      clear_neon_saturated();
      //  Expect: "result" = ffffffffffffffff
      result = vclez_s64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(result, 0);
      exp = UINT64_C(0xffffffffffffffff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_618() {

{
   {
      float64x1_t arg1;
      uint64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"clez\", fnname = \"vclez_f64\", rettype = \"uint64x1_t\", argtypes = \"[float64x1_t]\", vals = [VectorVal [FloatVal 0.6305231305599117]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_f64(UINT64_C(0x3fe42d3ed8240b22));
      clear_neon_saturated();
      //  Expect: "result" = 0000000000000000
      result = vclez_f64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(result, 0);
      exp = 0;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_619() {

{
   {
      int64x2_t arg1;
      uint64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"clez\", fnname = \"vclezq_s64\", rettype = \"uint64x2_t\", argtypes = \"[int64x2_t]\", vals = [VectorVal [IntegerVal (-9223231297218936833),IntegerVal 9223231299366354944]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s64(vcreate_s64(UINT64_C(0x800080007fffffff)),
                          vcreate_s64(UINT64_C(0x7fff7fffffff0000)));
      clear_neon_saturated();
      //  Expect: "result" = 0000000000000000ffffffffffffffff
      result = vclezq_s64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 0);
         exp = UINT64_C(0xffffffffffffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 1);
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_620() {

{
   {
      float64x2_t arg1;
      uint64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"clez\", fnname = \"vclezq_f64\", rettype = \"uint64x2_t\", argtypes = \"[float64x2_t]\", vals = [VectorVal [FloatVal 0.8991236333100927,FloatVal 0.7292216624729277]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_f64(vcreate_f64(UINT64_C(0x3fecc59eed0414d8)),
                          vcreate_f64(UINT64_C(0x3fe755c8aafb6426)));
      clear_neon_saturated();
      //  Expect: "result" = 00000000000000000000000000000000
      result = vclezq_f64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 0);
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 1);
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_621() {

{
   {
      int64_t arg1;
      uint64_t result;
      char* str1 = "ReproInfo2 {semantics = \"clez\", fnname = \"vclezd_s64\", rettype = \"uint64_t\", argtypes = \"[int64_t]\", vals = [IntegerVal (-140737488388097)], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = INT64_C(-140737488388097);
      clear_neon_saturated();
      //  Expect: "result" = ffffffffffffffff
      result = vclezd_s64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = UINT64_C(0xffffffffffffffff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_622() {

{
   {
      float32_t arg1;
      uint32_t result;
      char* str1 = "ReproInfo2 {semantics = \"clez\", fnname = \"vclezs_f32\", rettype = \"uint32_t\", argtypes = \"[float32_t]\", vals = [FloatVal 0.6022601127624512], start_saturated = False}";
      int reported = 0;
      uint32_t got;
      uint32_t exp;
      arg1 = ((float32_t) 0.6022601127624512);
      clear_neon_saturated();
      //  Expect: "result" = 00000000
      result = vclezs_f32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = 0;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIu32 " Got: %" PRIu32 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_623() {

{
   {
      float64_t arg1;
      uint64_t result;
      char* str1 = "ReproInfo2 {semantics = \"clez\", fnname = \"vclezd_f64\", rettype = \"uint64_t\", argtypes = \"[float64_t]\", vals = [FloatVal 0.7648048473958045], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = 0.7648048473958045;
      clear_neon_saturated();
      //  Expect: "result" = 0000000000000000
      result = vclezd_f64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = 0;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_624() {

{
   {
      int8x8_t arg1;
      uint8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"cltz\", fnname = \"vcltz_s8\", rettype = \"uint8x8_t\", argtypes = \"[int8x8_t]\", vals = [VectorVal [IntegerVal (-128),IntegerVal 127,IntegerVal 0,IntegerVal 127,IntegerVal (-1),IntegerVal (-128),IntegerVal 39,IntegerVal (-53)]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s8(UINT64_C(0xcb2780ff7f007f80));
      clear_neon_saturated();
      //  Expect: "result" = ff00ffff000000ff
      result = vcltz_s8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u8(result), 0);
      exp = UINT64_C(0xff00ffff000000ff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_625() {

{
   {
      int16x4_t arg1;
      uint16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"cltz\", fnname = \"vcltz_s16\", rettype = \"uint16x4_t\", argtypes = \"[int16x4_t]\", vals = [VectorVal [IntegerVal 32767,IntegerVal 0,IntegerVal 0,IntegerVal (-1)]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s16(UINT64_C(0xffff000000007fff));
      clear_neon_saturated();
      //  Expect: "result" = ffff000000000000
      result = vcltz_s16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u16(result), 0);
      exp = UINT64_C(0xffff000000000000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_626() {

{
   {
      int32x2_t arg1;
      uint32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"cltz\", fnname = \"vcltz_s32\", rettype = \"uint32x2_t\", argtypes = \"[int32x2_t]\", vals = [VectorVal [IntegerVal 2147418112,IntegerVal 32767]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s32(UINT64_C(0x00007fff7fff0000));
      clear_neon_saturated();
      //  Expect: "result" = 0000000000000000
      result = vcltz_s32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u32(result), 0);
      exp = 0;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_627() {

{
   {
      float32x2_t arg1;
      uint32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"cltz\", fnname = \"vcltz_f32\", rettype = \"uint32x2_t\", argtypes = \"[float32x2_t]\", vals = [VectorVal [FloatVal 0.37706494331359863,FloatVal 0.6773056983947754]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_f32(UINT64_C(0x3f2d63e83ec10ea8));
      clear_neon_saturated();
      //  Expect: "result" = 0000000000000000
      result = vcltz_f32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u32(result), 0);
      exp = 0;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_628() {

{
   {
      int8x16_t arg1;
      uint8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"cltz\", fnname = \"vcltzq_s8\", rettype = \"uint8x16_t\", argtypes = \"[int8x16_t]\", vals = [VectorVal [IntegerVal (-1),IntegerVal 0,IntegerVal 0,IntegerVal (-1),IntegerVal 0,IntegerVal (-128),IntegerVal (-1),IntegerVal (-128),IntegerVal (-128),IntegerVal (-1),IntegerVal 0,IntegerVal 0,IntegerVal 127,IntegerVal 38,IntegerVal (-1),IntegerVal (-1)]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s8(vcreate_s8(UINT64_C(0x80ff8000ff0000ff)),
                         vcreate_s8(UINT64_C(0xffff267f0000ff80)));
      clear_neon_saturated();
      //  Expect: "result" = ffff00000000ffffffffff00ff0000ff
      result = vcltzq_s8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 0);
         exp = UINT64_C(0xffffff00ff0000ff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 1);
         exp = UINT64_C(0xffff00000000ffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_629() {

{
   {
      int16x8_t arg1;
      uint16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"cltz\", fnname = \"vcltzq_s16\", rettype = \"uint16x8_t\", argtypes = \"[int16x8_t]\", vals = [VectorVal [IntegerVal 32767,IntegerVal (-32768),IntegerVal (-32768),IntegerVal (-1),IntegerVal (-32768),IntegerVal (-32768),IntegerVal (-1),IntegerVal (-32768)]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s16(vcreate_s16(UINT64_C(0xffff800080007fff)),
                          vcreate_s16(UINT64_C(0x8000ffff80008000)));
      clear_neon_saturated();
      //  Expect: "result" = ffffffffffffffffffffffffffff0000
      result = vcltzq_s16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 0);
         exp = UINT64_C(0xffffffffffff0000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 1);
         exp = UINT64_C(0xffffffffffffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_630() {

{
   {
      int32x4_t arg1;
      uint32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"cltz\", fnname = \"vcltzq_s32\", rettype = \"uint32x4_t\", argtypes = \"[int32x4_t]\", vals = [VectorVal [IntegerVal (-1),IntegerVal 1879375871,IntegerVal 0,IntegerVal (-32768)]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s32(vcreate_s32(UINT64_C(0x7004ffffffffffff)),
                          vcreate_s32(UINT64_C(0xffff800000000000)));
      clear_neon_saturated();
      //  Expect: "result" = ffffffff0000000000000000ffffffff
      result = vcltzq_s32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 0);
         exp = UINT64_C(0x00000000ffffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 1);
         exp = UINT64_C(0xffffffff00000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_631() {

{
   {
      float32x4_t arg1;
      uint32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"cltz\", fnname = \"vcltzq_f32\", rettype = \"uint32x4_t\", argtypes = \"[float32x4_t]\", vals = [VectorVal [FloatVal 0.7054845690727234,FloatVal 0.3215301036834717,FloatVal 0.1524292230606079,FloatVal 0.8435098528862]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_f32(vcreate_f32(UINT64_C(0x3ea49f983f349aa3)),
                          vcreate_f32(UINT64_C(0x3f57f0433e1c1668)));
      clear_neon_saturated();
      //  Expect: "result" = 00000000000000000000000000000000
      result = vcltzq_f32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 0);
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 1);
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_632() {

{
   {
      int64x1_t arg1;
      uint64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"cltz\", fnname = \"vcltz_s64\", rettype = \"uint64x1_t\", argtypes = \"[int64x1_t]\", vals = [VectorVal [IntegerVal 140737488388096]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s64(UINT64_C(0x0000800000008000));
      clear_neon_saturated();
      //  Expect: "result" = 0000000000000000
      result = vcltz_s64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(result, 0);
      exp = 0;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_633() {

{
   {
      float64x1_t arg1;
      uint64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"cltz\", fnname = \"vcltz_f64\", rettype = \"uint64x1_t\", argtypes = \"[float64x1_t]\", vals = [VectorVal [FloatVal 0.41895693553055136]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_f64(UINT64_C(0x3fdad030c0224f70));
      clear_neon_saturated();
      //  Expect: "result" = 0000000000000000
      result = vcltz_f64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(result, 0);
      exp = 0;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_634() {

{
   {
      int64x2_t arg1;
      uint64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"cltz\", fnname = \"vcltzq_s64\", rettype = \"uint64x2_t\", argtypes = \"[int64x2_t]\", vals = [VectorVal [IntegerVal 9223231298751587682,IntegerVal (-4294967296)]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s64(vcreate_s64(UINT64_C(0x7fff7fffdb5a6562)),
                          vcreate_s64(UINT64_C(0xffffffff00000000)));
      clear_neon_saturated();
      //  Expect: "result" = ffffffffffffffff0000000000000000
      result = vcltzq_s64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 0);
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 1);
         exp = UINT64_C(0xffffffffffffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_635() {

{
   {
      float64x2_t arg1;
      uint64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"cltz\", fnname = \"vcltzq_f64\", rettype = \"uint64x2_t\", argtypes = \"[float64x2_t]\", vals = [VectorVal [FloatVal 0.78900450626454,FloatVal 0.282705776126291]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_f64(vcreate_f64(UINT64_C(0x3fe93f8660d9b0c1)),
                          vcreate_f64(UINT64_C(0x3fd217d9f7b692ec)));
      clear_neon_saturated();
      //  Expect: "result" = 00000000000000000000000000000000
      result = vcltzq_f64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 0);
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 1);
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_636() {

{
   {
      int64_t arg1;
      uint64_t result;
      char* str1 = "ReproInfo2 {semantics = \"cltz\", fnname = \"vcltzd_s64\", rettype = \"uint64_t\", argtypes = \"[int64_t]\", vals = [IntegerVal 6664042203167326207], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = INT64_C(6664042203167326207);
      clear_neon_saturated();
      //  Expect: "result" = 0000000000000000
      result = vcltzd_s64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = 0;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_637() {

{
   {
      float32_t arg1;
      uint32_t result;
      char* str1 = "ReproInfo2 {semantics = \"cltz\", fnname = \"vcltzs_f32\", rettype = \"uint32_t\", argtypes = \"[float32_t]\", vals = [FloatVal 0.8574256896972656], start_saturated = False}";
      int reported = 0;
      uint32_t got;
      uint32_t exp;
      arg1 = ((float32_t) 0.8574256896972656);
      clear_neon_saturated();
      //  Expect: "result" = 00000000
      result = vcltzs_f32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = 0;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIu32 " Got: %" PRIu32 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_638() {

{
   {
      float64_t arg1;
      uint64_t result;
      char* str1 = "ReproInfo2 {semantics = \"cltz\", fnname = \"vcltzd_f64\", rettype = \"uint64_t\", argtypes = \"[float64_t]\", vals = [FloatVal 2.9761023049996727e-2], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = 2.9761023049996727e-2;
      clear_neon_saturated();
      //  Expect: "result" = 0000000000000000
      result = vcltzd_f64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = 0;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_639() {

{
   {
      int8x8_t arg1;
      int8x8_t arg2;
      int8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"abd\", fnname = \"vabd_s8\", rettype = \"int8x8_t\", argtypes = \"[int8x8_t,int8x8_t]\", vals = [VectorVal [IntegerVal (-128),IntegerVal 0,IntegerVal (-94),IntegerVal (-128),IntegerVal (-128),IntegerVal 0,IntegerVal (-1),IntegerVal (-1)],VectorVal [IntegerVal 0,IntegerVal (-128),IntegerVal (-1),IntegerVal (-1),IntegerVal (-128),IntegerVal 0,IntegerVal 127,IntegerVal (-1)]], start_saturated = True}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s8(UINT64_C(0xffff008080a20080));
      arg2 = vcreate_s8(UINT64_C(0xff7f0080ffff8000));
      set_neon_saturated();
      //  Expect: "result" = 008000007f5d8080
      result = vabd_s8(arg1, arg2);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s8(result), 0);
      exp = UINT64_C(0x008000007f5d8080);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_640() {

{
   {
      int16x4_t arg1;
      int16x4_t arg2;
      int16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"abd\", fnname = \"vabd_s16\", rettype = \"int16x4_t\", argtypes = \"[int16x4_t,int16x4_t]\", vals = [VectorVal [IntegerVal (-1),IntegerVal 32767,IntegerVal (-32768),IntegerVal 19546],VectorVal [IntegerVal (-7856),IntegerVal (-2010),IntegerVal (-1),IntegerVal (-32768)]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s16(UINT64_C(0x4c5a80007fffffff));
      arg2 = vcreate_s16(UINT64_C(0x8000fffff826e150));
      clear_neon_saturated();
      //  Expect: "result" = cc5a7fff87d91eaf
      result = vabd_s16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s16(result), 0);
      exp = UINT64_C(0xcc5a7fff87d91eaf);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_641() {

{
   {
      int32x2_t arg1;
      int32x2_t arg2;
      int32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"abd\", fnname = \"vabd_s32\", rettype = \"int32x2_t\", argtypes = \"[int32x2_t,int32x2_t]\", vals = [VectorVal [IntegerVal 0,IntegerVal (-192479232)],VectorVal [IntegerVal 878903296,IntegerVal 2147483647]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s32(UINT64_C(0xf487000000000000));
      arg2 = vcreate_s32(UINT64_C(0x7fffffff34630000));
      clear_neon_saturated();
      //  Expect: "result" = 8b78ffff34630000
      result = vabd_s32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s32(result), 0);
      exp = UINT64_C(0x8b78ffff34630000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_642() {

{
   {
      uint8x8_t arg1;
      uint8x8_t arg2;
      uint8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"abd\", fnname = \"vabd_u8\", rettype = \"uint8x8_t\", argtypes = \"[uint8x8_t,uint8x8_t]\", vals = [VectorVal [IntegerVal 162,IntegerVal 162,IntegerVal 127,IntegerVal 127,IntegerVal 0,IntegerVal 128,IntegerVal 0,IntegerVal 127],VectorVal [IntegerVal 0,IntegerVal 0,IntegerVal 127,IntegerVal 41,IntegerVal 128,IntegerVal 255,IntegerVal 127,IntegerVal 0]], start_saturated = True}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u8(UINT64_C(0x7f0080007f7fa2a2));
      arg2 = vcreate_u8(UINT64_C(0x007fff80297f0000));
      set_neon_saturated();
      //  Expect: "result" = 7f7f7f805600a2a2
      result = vabd_u8(arg1, arg2);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u8(result), 0);
      exp = UINT64_C(0x7f7f7f805600a2a2);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_643() {

{
   {
      uint16x4_t arg1;
      uint16x4_t arg2;
      uint16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"abd\", fnname = \"vabd_u16\", rettype = \"uint16x4_t\", argtypes = \"[uint16x4_t,uint16x4_t]\", vals = [VectorVal [IntegerVal 5589,IntegerVal 32767,IntegerVal 0,IntegerVal 32767],VectorVal [IntegerVal 32767,IntegerVal 32767,IntegerVal 14763,IntegerVal 65535]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u16(UINT64_C(0x7fff00007fff15d5));
      arg2 = vcreate_u16(UINT64_C(0xffff39ab7fff7fff));
      clear_neon_saturated();
      //  Expect: "result" = 800039ab00006a2a
      result = vabd_u16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u16(result), 0);
      exp = UINT64_C(0x800039ab00006a2a);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_644() {

{
   {
      uint32x2_t arg1;
      uint32x2_t arg2;
      uint32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"abd\", fnname = \"vabd_u32\", rettype = \"uint32x2_t\", argtypes = \"[uint32x2_t,uint32x2_t]\", vals = [VectorVal [IntegerVal 32768,IntegerVal 0],VectorVal [IntegerVal 2147450879,IntegerVal 4294901760]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u32(UINT64_C(0x0000000000008000));
      arg2 = vcreate_u32(UINT64_C(0xffff00007fff7fff));
      clear_neon_saturated();
      //  Expect: "result" = ffff00007ffeffff
      result = vabd_u32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u32(result), 0);
      exp = UINT64_C(0xffff00007ffeffff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_645() {

{
   {
      float32x2_t arg1;
      float32x2_t arg2;
      float32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"abd\", fnname = \"vabd_f32\", rettype = \"float32x2_t\", argtypes = \"[float32x2_t,float32x2_t]\", vals = [VectorVal [FloatVal 2.02178955078125e-3,FloatVal 0.11119794845581055],VectorVal [FloatVal 4.080498218536377e-2,FloatVal 0.9316855669021606]], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_f32(UINT64_C(0x3de3bbc03b048000));
      arg2 = vcreate_f32(UINT64_C(0x3f6e82f23d272320));
      clear_neon_saturated();
      //  Expect: "result" = 3f520b7a3d1edb20
      result = vabd_f32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result, 0);
         exp = ((float32_t) 3.878319263458252e-2);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result, 1);
         exp = ((float32_t) 0.8204876184463501);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
   }
}
}
void dotests_646() {

{
   {
      int8x16_t arg1;
      int8x16_t arg2;
      int8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"abd\", fnname = \"vabdq_s8\", rettype = \"int8x16_t\", argtypes = \"[int8x16_t,int8x16_t]\", vals = [VectorVal [IntegerVal (-1),IntegerVal (-7),IntegerVal 127,IntegerVal (-97),IntegerVal (-128),IntegerVal (-128),IntegerVal 0,IntegerVal (-1),IntegerVal 0,IntegerVal (-38),IntegerVal (-1),IntegerVal (-128),IntegerVal 125,IntegerVal (-128),IntegerVal 0,IntegerVal (-1)],VectorVal [IntegerVal (-33),IntegerVal (-1),IntegerVal 127,IntegerVal 0,IntegerVal 0,IntegerVal 127,IntegerVal (-128),IntegerVal (-1),IntegerVal 127,IntegerVal (-128),IntegerVal (-1),IntegerVal (-1),IntegerVal 0,IntegerVal (-1),IntegerVal 0,IntegerVal 0]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s8(vcreate_s8(UINT64_C(0xff0080809f7ff9ff)),
                         vcreate_s8(UINT64_C(0xff00807d80ffda00)));
      arg2 = vcombine_s8(vcreate_s8(UINT64_C(0xff807f00007fffdf)),
                         vcreate_s8(UINT64_C(0x0000ff00ffff807f)));
      clear_neon_saturated();
      //  Expect: "result" = 01007f7d7f005a7f0080ff8061000620
      result = vabdq_s8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result), 0);
         exp = UINT64_C(0x0080ff8061000620);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result), 1);
         exp = UINT64_C(0x01007f7d7f005a7f);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_647() {

{
   {
      int16x8_t arg1;
      int16x8_t arg2;
      int16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"abd\", fnname = \"vabdq_s16\", rettype = \"int16x8_t\", argtypes = \"[int16x8_t,int16x8_t]\", vals = [VectorVal [IntegerVal (-1),IntegerVal 0,IntegerVal 0,IntegerVal (-1),IntegerVal 0,IntegerVal 2209,IntegerVal 20114,IntegerVal 32767],VectorVal [IntegerVal (-32768),IntegerVal (-1),IntegerVal 0,IntegerVal (-1),IntegerVal (-1),IntegerVal 0,IntegerVal (-1),IntegerVal (-32768)]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s16(vcreate_s16(UINT64_C(0xffff00000000ffff)),
                          vcreate_s16(UINT64_C(0x7fff4e9208a10000)));
      arg2 = vcombine_s16(vcreate_s16(UINT64_C(0xffff0000ffff8000)),
                          vcreate_s16(UINT64_C(0x8000ffff0000ffff)));
      clear_neon_saturated();
      //  Expect: "result" = ffff4e9308a100010000000000017fff
      result = vabdq_s16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 0);
         exp = UINT64_C(0x0000000000017fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 1);
         exp = UINT64_C(0xffff4e9308a10001);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_648() {

{
   {
      int32x4_t arg1;
      int32x4_t arg2;
      int32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"abd\", fnname = \"vabdq_s32\", rettype = \"int32x4_t\", argtypes = \"[int32x4_t,int32x4_t]\", vals = [VectorVal [IntegerVal 2147483647,IntegerVal (-2147483648),IntegerVal (-32768),IntegerVal (-2147483648)],VectorVal [IntegerVal 61999,IntegerVal (-2147418113),IntegerVal 2147483647,IntegerVal (-42562)]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s32(vcreate_s32(UINT64_C(0x800000007fffffff)),
                          vcreate_s32(UINT64_C(0x80000000ffff8000)));
      arg2 = vcombine_s32(vcreate_s32(UINT64_C(0x8000ffff0000f22f)),
                          vcreate_s32(UINT64_C(0xffff59be7fffffff)));
      clear_neon_saturated();
      //  Expect: "result" = 7fff59be80007fff0000ffff7fff0dd0
      result = vabdq_s32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 0);
         exp = UINT64_C(0x0000ffff7fff0dd0);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 1);
         exp = UINT64_C(0x7fff59be80007fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_649() {

{
   {
      uint8x16_t arg1;
      uint8x16_t arg2;
      uint8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"abd\", fnname = \"vabdq_u8\", rettype = \"uint8x16_t\", argtypes = \"[uint8x16_t,uint8x16_t]\", vals = [VectorVal [IntegerVal 0,IntegerVal 127,IntegerVal 128,IntegerVal 0,IntegerVal 128,IntegerVal 127,IntegerVal 127,IntegerVal 0,IntegerVal 127,IntegerVal 0,IntegerVal 127,IntegerVal 127,IntegerVal 128,IntegerVal 128,IntegerVal 128,IntegerVal 202],VectorVal [IntegerVal 127,IntegerVal 0,IntegerVal 128,IntegerVal 255,IntegerVal 87,IntegerVal 255,IntegerVal 128,IntegerVal 255,IntegerVal 223,IntegerVal 0,IntegerVal 0,IntegerVal 0,IntegerVal 127,IntegerVal 0,IntegerVal 128,IntegerVal 0]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u8(vcreate_u8(UINT64_C(0x007f7f8000807f00)),
                         vcreate_u8(UINT64_C(0xca8080807f7f007f)));
      arg2 = vcombine_u8(vcreate_u8(UINT64_C(0xff80ff57ff80007f)),
                         vcreate_u8(UINT64_C(0x0080007f000000df)));
      clear_neon_saturated();
      //  Expect: "result" = ca0080017f7f0060ff018029ff007f7f
      result = vabdq_u8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 0);
         exp = UINT64_C(0xff018029ff007f7f);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 1);
         exp = UINT64_C(0xca0080017f7f0060);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_650() {

{
   {
      uint16x8_t arg1;
      uint16x8_t arg2;
      uint16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"abd\", fnname = \"vabdq_u16\", rettype = \"uint16x8_t\", argtypes = \"[uint16x8_t,uint16x8_t]\", vals = [VectorVal [IntegerVal 32768,IntegerVal 26431,IntegerVal 32768,IntegerVal 65535,IntegerVal 32767,IntegerVal 31593,IntegerVal 35761,IntegerVal 32767],VectorVal [IntegerVal 65535,IntegerVal 32767,IntegerVal 32768,IntegerVal 0,IntegerVal 0,IntegerVal 0,IntegerVal 32768,IntegerVal 0]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u16(vcreate_u16(UINT64_C(0xffff8000673f8000)),
                          vcreate_u16(UINT64_C(0x7fff8bb17b697fff)));
      arg2 = vcombine_u16(vcreate_u16(UINT64_C(0x000080007fffffff)),
                          vcreate_u16(UINT64_C(0x0000800000000000)));
      clear_neon_saturated();
      //  Expect: "result" = 7fff0bb17b697fffffff000018c07fff
      result = vabdq_u16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 0);
         exp = UINT64_C(0xffff000018c07fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 1);
         exp = UINT64_C(0x7fff0bb17b697fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_651() {

{
   {
      uint32x4_t arg1;
      uint32x4_t arg2;
      uint32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"abd\", fnname = \"vabdq_u32\", rettype = \"uint32x4_t\", argtypes = \"[uint32x4_t,uint32x4_t]\", vals = [VectorVal [IntegerVal 4294901760,IntegerVal 2147527751,IntegerVal 2147533765,IntegerVal 4294901760],VectorVal [IntegerVal 1926758399,IntegerVal 4294901760,IntegerVal 2147516416,IntegerVal 4294901760]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u32(vcreate_u32(UINT64_C(0x8000ac47ffff0000)),
                          vcreate_u32(UINT64_C(0xffff00008000c3c5)));
      arg2 = vcombine_u32(vcreate_u32(UINT64_C(0xffff000072d7ffff)),
                          vcreate_u32(UINT64_C(0xffff000080008000)));
      clear_neon_saturated();
      //  Expect: "result" = 00000000000043c57ffe53b98d270001
      result = vabdq_u32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 0);
         exp = UINT64_C(0x7ffe53b98d270001);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 1);
         exp = UINT64_C(0x00000000000043c5);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_652() {

{
   {
      float32x4_t arg1;
      float32x4_t arg2;
      float32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"abd\", fnname = \"vabdq_f32\", rettype = \"float32x4_t\", argtypes = \"[float32x4_t,float32x4_t]\", vals = [VectorVal [FloatVal 0.9622695446014404,FloatVal 0.5165830254554749,FloatVal 0.11118495464324951,FloatVal 0.19632405042648315],VectorVal [FloatVal 0.6896831393241882,FloatVal 0.9696733355522156,FloatVal 0.7943057417869568,FloatVal 0.929138720035553]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_f32(vcreate_f32(UINT64_C(0x3f043ec93f76574c)),
                          vcreate_f32(UINT64_C(0x3e49092c3de3b4f0)));
      arg2 = vcombine_f32(vcreate_f32(UINT64_C(0x3f783c833f308f13)),
                          vcreate_f32(UINT64_C(0x3f6ddc093f4b579f)));
      clear_neon_saturated();
      //  Expect: "result" = 3f3b99be3f2ee1013ee7fb743e8b9072
      result = vabdq_f32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 0);
         exp = ((float32_t) 0.2725864052772522);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 1);
         exp = ((float32_t) 0.4530903100967407);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 2);
         exp = ((float32_t) 0.6831207871437073);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 2 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 3);
         exp = ((float32_t) 0.7328146696090698);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 3 ", exp, got);
            }
      }
   }
}
}
void dotests_653() {

{
   {
      float64x1_t arg1;
      float64x1_t arg2;
      float64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"abd\", fnname = \"vabd_f64\", rettype = \"float64x1_t\", argtypes = \"[float64x1_t,float64x1_t]\", vals = [VectorVal [FloatVal 0.6480327046521677],VectorVal [FloatVal 0.9194886306193403]], start_saturated = False}";
      int reported = 0;
      float64_t got;
      float64_t exp;
      arg1 = vcreate_f64(UINT64_C(0x3fe4bcaf1527060a));
      arg2 = vcreate_f64(UINT64_C(0x3fed6c736bb1b979));
      clear_neon_saturated();
      //  Expect: "result" = 3fd15f88ad1566de
      result = vabd_f64(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_f64(result, 0);
      exp = 0.2714559259671726;
      if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
         }
   }
}
}
void dotests_654() {

{
   {
      float64x2_t arg1;
      float64x2_t arg2;
      float64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"abd\", fnname = \"vabdq_f64\", rettype = \"float64x2_t\", argtypes = \"[float64x2_t,float64x2_t]\", vals = [VectorVal [FloatVal 0.2896551803233991,FloatVal 0.29613444383701837],VectorVal [FloatVal 3.522562252928785e-2,FloatVal 0.23962622509351983]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_f64(vcreate_f64(UINT64_C(0x3fd289b5e1a6c868)),
                          vcreate_f64(UINT64_C(0x3fd2f3dde1dff1f4)));
      arg2 = vcombine_f64(vcreate_f64(UINT64_C(0x3fa20917c17d3350)),
                          vcreate_f64(UINT64_C(0x3fceac1278053274)));
      clear_neon_saturated();
      //  Expect: "result" = 3faceea52eeac5d03fd04892e97721fe
      result = vabdq_f64(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float64_t got;
         float64_t exp;
         got = vgetq_lane_f64(result, 0);
         exp = 0.25442955779411125;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float64_t got;
         float64_t exp;
         got = vgetq_lane_f64(result, 1);
         exp = 5.650821874349854e-2;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
   }
}
}
void dotests_655() {

{
   {
      float32_t arg1;
      float32_t arg2;
      float32_t result;
      char* str1 = "ReproInfo2 {semantics = \"abd\", fnname = \"vabds_f32\", rettype = \"float32_t\", argtypes = \"[float32_t,float32_t]\", vals = [FloatVal 7.306039333343506e-2,FloatVal 0.5397093892097473], start_saturated = False}";
      int reported = 0;
      float32_t got;
      float32_t exp;
      arg1 = ((float32_t) 7.306039333343506e-2);
      arg2 = ((float32_t) 0.5397093892097473);
      clear_neon_saturated();
      //  Expect: "result" = 3eeeec9e
      result = vabds_f32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = ((float32_t) 0.46664899587631226);
      if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %f Got: %f\n", "   ", exp, got);
         }
   }
}
}
void dotests_656() {

{
   {
      float64_t arg1;
      float64_t arg2;
      float64_t result;
      char* str1 = "ReproInfo2 {semantics = \"abd\", fnname = \"vabdd_f64\", rettype = \"float64_t\", argtypes = \"[float64_t,float64_t]\", vals = [FloatVal 0.7753305783490873,FloatVal 0.3574871893955299], start_saturated = False}";
      int reported = 0;
      float64_t got;
      float64_t exp;
      arg1 = 0.7753305783490873;
      arg2 = 0.3574871893955299;
      clear_neon_saturated();
      //  Expect: "result" = 3fdabdf23299f108
      result = vabdd_f64(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = 0.4178433889535573;
      if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %f Got: %f\n", "   ", exp, got);
         }
   }
}
}
void dotests_657() {

{
   {
      int8x8_t arg1;
      int8x8_t arg2;
      int16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"abd\", fnname = \"vabdl_s8\", rettype = \"int16x8_t\", argtypes = \"[int8x8_t,int8x8_t]\", vals = [VectorVal [IntegerVal 0,IntegerVal (-128),IntegerVal (-128),IntegerVal (-128),IntegerVal 127,IntegerVal 118,IntegerVal (-1),IntegerVal 127],VectorVal [IntegerVal 76,IntegerVal (-1),IntegerVal 0,IntegerVal (-128),IntegerVal 127,IntegerVal 58,IntegerVal 127,IntegerVal (-1)]], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_s8(UINT64_C(0x7fff767f80808000));
      arg2 = vcreate_s8(UINT64_C(0xff7f3a7f8000ff4c));
      clear_neon_saturated();
      //  Expect: "result" = 00800080003c000000000080007f004c
      result = vabdl_s8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 0);
         exp = UINT64_C(0x00000080007f004c);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 1);
         exp = UINT64_C(0x00800080003c0000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_658() {

{
   {
      int16x4_t arg1;
      int16x4_t arg2;
      int32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"abd\", fnname = \"vabdl_s16\", rettype = \"int32x4_t\", argtypes = \"[int16x4_t,int16x4_t]\", vals = [VectorVal [IntegerVal 4387,IntegerVal 32767,IntegerVal (-32768),IntegerVal 18744],VectorVal [IntegerVal (-1),IntegerVal 32767,IntegerVal (-27131),IntegerVal (-1)]], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_s16(UINT64_C(0x493880007fff1123));
      arg2 = vcreate_s16(UINT64_C(0xffff96057fffffff));
      clear_neon_saturated();
      //  Expect: "result" = 00004939000016050000000000001124
      result = vabdl_s16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 0);
         exp = UINT64_C(0x0000000000001124);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 1);
         exp = UINT64_C(0x0000493900001605);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_659() {

{
   {
      int32x2_t arg1;
      int32x2_t arg2;
      int64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"abd\", fnname = \"vabdl_s32\", rettype = \"int64x2_t\", argtypes = \"[int32x2_t,int32x2_t]\", vals = [VectorVal [IntegerVal (-2147483648),IntegerVal (-2147450881)],VectorVal [IntegerVal (-2147450881),IntegerVal (-2147483648)]], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_s32(UINT64_C(0x80007fff80000000));
      arg2 = vcreate_s32(UINT64_C(0x8000000080007fff));
      clear_neon_saturated();
      //  Expect: "result" = 0000000000007fff0000000000007fff
      result = vabdl_s32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 0);
         exp = UINT64_C(0x0000000000007fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 1);
         exp = UINT64_C(0x0000000000007fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_660() {

{
   {
      uint8x8_t arg1;
      uint8x8_t arg2;
      uint16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"abd\", fnname = \"vabdl_u8\", rettype = \"uint16x8_t\", argtypes = \"[uint8x8_t,uint8x8_t]\", vals = [VectorVal [IntegerVal 71,IntegerVal 60,IntegerVal 255,IntegerVal 127,IntegerVal 101,IntegerVal 0,IntegerVal 128,IntegerVal 128],VectorVal [IntegerVal 0,IntegerVal 128,IntegerVal 255,IntegerVal 0,IntegerVal 128,IntegerVal 128,IntegerVal 0,IntegerVal 255]], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_u8(UINT64_C(0x808000657fff3c47));
      arg2 = vcreate_u8(UINT64_C(0xff00808000ff8000));
      clear_neon_saturated();
      //  Expect: "result" = 007f00800080001b007f000000440047
      result = vabdl_u8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 0);
         exp = UINT64_C(0x007f000000440047);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 1);
         exp = UINT64_C(0x007f00800080001b);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_661() {

{
   {
      uint16x4_t arg1;
      uint16x4_t arg2;
      uint32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"abd\", fnname = \"vabdl_u16\", rettype = \"uint32x4_t\", argtypes = \"[uint16x4_t,uint16x4_t]\", vals = [VectorVal [IntegerVal 65535,IntegerVal 32767,IntegerVal 65535,IntegerVal 0],VectorVal [IntegerVal 65535,IntegerVal 32768,IntegerVal 0,IntegerVal 32767]], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_u16(UINT64_C(0x0000ffff7fffffff));
      arg2 = vcreate_u16(UINT64_C(0x7fff00008000ffff));
      clear_neon_saturated();
      //  Expect: "result" = 00007fff0000ffff0000000100000000
      result = vabdl_u16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 0);
         exp = UINT64_C(0x0000000100000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 1);
         exp = UINT64_C(0x00007fff0000ffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_662() {

{
   {
      uint32x2_t arg1;
      uint32x2_t arg2;
      uint64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"abd\", fnname = \"vabdl_u32\", rettype = \"uint64x2_t\", argtypes = \"[uint32x2_t,uint32x2_t]\", vals = [VectorVal [IntegerVal 65535,IntegerVal 32768],VectorVal [IntegerVal 4204003328,IntegerVal 4294901760]], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_u32(UINT64_C(0x000080000000ffff));
      arg2 = vcreate_u32(UINT64_C(0xffff0000fa940000));
      clear_neon_saturated();
      //  Expect: "result" = 00000000fffe800000000000fa930001
      result = vabdl_u32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 0);
         exp = UINT64_C(0x00000000fa930001);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 1);
         exp = UINT64_C(0x00000000fffe8000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_663() {

{
   {
      int8x16_t arg1;
      int8x16_t arg2;
      int16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"abd\", fnname = \"vabdl_high_s8\", rettype = \"int16x8_t\", argtypes = \"[int8x16_t,int8x16_t]\", vals = [VectorVal [IntegerVal 0,IntegerVal (-1),IntegerVal 127,IntegerVal 127,IntegerVal (-1),IntegerVal 5,IntegerVal 0,IntegerVal 0,IntegerVal (-128),IntegerVal (-1),IntegerVal 0,IntegerVal (-128),IntegerVal (-1),IntegerVal (-128),IntegerVal (-128),IntegerVal 0],VectorVal [IntegerVal 127,IntegerVal (-1),IntegerVal 0,IntegerVal (-1),IntegerVal 127,IntegerVal (-1),IntegerVal 0,IntegerVal 127,IntegerVal (-1),IntegerVal 0,IntegerVal 127,IntegerVal (-1),IntegerVal 56,IntegerVal 127,IntegerVal (-71),IntegerVal 127]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s8(vcreate_s8(UINT64_C(0x000005ff7f7fff00)),
                         vcreate_s8(UINT64_C(0x008080ff8000ff80)));
      arg2 = vcombine_s8(vcreate_s8(UINT64_C(0x7f00ff7fff00ff7f)),
                         vcreate_s8(UINT64_C(0x7fb97f38ff7f00ff)));
      clear_neon_saturated();
      //  Expect: "result" = 007f003900ff0039007f007f0001007f
      result = vabdl_high_s8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 0);
         exp = UINT64_C(0x007f007f0001007f);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 1);
         exp = UINT64_C(0x007f003900ff0039);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_664() {

{
   {
      int16x8_t arg1;
      int16x8_t arg2;
      int32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"abd\", fnname = \"vabdl_high_s16\", rettype = \"int32x4_t\", argtypes = \"[int16x8_t,int16x8_t]\", vals = [VectorVal [IntegerVal (-12763),IntegerVal 32767,IntegerVal 32767,IntegerVal 16672,IntegerVal 32767,IntegerVal 16296,IntegerVal 0,IntegerVal (-32768)],VectorVal [IntegerVal (-32768),IntegerVal 0,IntegerVal (-32768),IntegerVal (-32768),IntegerVal (-32768),IntegerVal (-1),IntegerVal (-32768),IntegerVal 0]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s16(vcreate_s16(UINT64_C(0x41207fff7fffce25)),
                          vcreate_s16(UINT64_C(0x800000003fa87fff)));
      arg2 = vcombine_s16(vcreate_s16(UINT64_C(0x8000800000008000)),
                          vcreate_s16(UINT64_C(0x00008000ffff8000)));
      clear_neon_saturated();
      //  Expect: "result" = 000080000000800000003fa90000ffff
      result = vabdl_high_s16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 0);
         exp = UINT64_C(0x00003fa90000ffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 1);
         exp = UINT64_C(0x0000800000008000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_665() {

{
   {
      int32x4_t arg1;
      int32x4_t arg2;
      int64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"abd\", fnname = \"vabdl_high_s32\", rettype = \"int64x2_t\", argtypes = \"[int32x4_t,int32x4_t]\", vals = [VectorVal [IntegerVal (-117243904),IntegerVal (-2147474796),IntegerVal 32767,IntegerVal (-65536)],VectorVal [IntegerVal 0,IntegerVal 0,IntegerVal 0,IntegerVal (-32769)]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s32(vcreate_s32(UINT64_C(0x80002294f9030000)),
                          vcreate_s32(UINT64_C(0xffff000000007fff)));
      arg2 = vcombine_s32(vcreate_s32(0),
                          vcreate_s32(UINT64_C(0xffff7fff00000000)));
      clear_neon_saturated();
      //  Expect: "result" = 0000000000007fff0000000000007fff
      result = vabdl_high_s32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 0);
         exp = UINT64_C(0x0000000000007fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 1);
         exp = UINT64_C(0x0000000000007fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_666() {

{
   {
      uint8x16_t arg1;
      uint8x16_t arg2;
      uint16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"abd\", fnname = \"vabdl_high_u8\", rettype = \"uint16x8_t\", argtypes = \"[uint8x16_t,uint8x16_t]\", vals = [VectorVal [IntegerVal 128,IntegerVal 128,IntegerVal 128,IntegerVal 127,IntegerVal 255,IntegerVal 255,IntegerVal 128,IntegerVal 139,IntegerVal 127,IntegerVal 127,IntegerVal 127,IntegerVal 255,IntegerVal 255,IntegerVal 0,IntegerVal 127,IntegerVal 0],VectorVal [IntegerVal 128,IntegerVal 128,IntegerVal 255,IntegerVal 128,IntegerVal 0,IntegerVal 222,IntegerVal 255,IntegerVal 0,IntegerVal 255,IntegerVal 128,IntegerVal 127,IntegerVal 0,IntegerVal 128,IntegerVal 182,IntegerVal 128,IntegerVal 124]], start_saturated = True}";
      int reported = 0;
      arg1 = vcombine_u8(vcreate_u8(UINT64_C(0x8b80ffff7f808080)),
                         vcreate_u8(UINT64_C(0x007f00ffff7f7f7f)));
      arg2 = vcombine_u8(vcreate_u8(UINT64_C(0x00ffde0080ff8080)),
                         vcreate_u8(UINT64_C(0x7c80b680007f80ff)));
      set_neon_saturated();
      //  Expect: "result" = 007c000100b6007f00ff000000010080
      result = vabdl_high_u8(arg1, arg2);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 0);
         exp = UINT64_C(0x00ff000000010080);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 1);
         exp = UINT64_C(0x007c000100b6007f);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_667() {

{
   {
      uint16x8_t arg1;
      uint16x8_t arg2;
      uint32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"abd\", fnname = \"vabdl_high_u16\", rettype = \"uint32x4_t\", argtypes = \"[uint16x8_t,uint16x8_t]\", vals = [VectorVal [IntegerVal 32768,IntegerVal 65535,IntegerVal 65535,IntegerVal 36954,IntegerVal 32767,IntegerVal 55524,IntegerVal 41552,IntegerVal 0],VectorVal [IntegerVal 32767,IntegerVal 32767,IntegerVal 65535,IntegerVal 32768,IntegerVal 65535,IntegerVal 32768,IntegerVal 32768,IntegerVal 65535]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u16(vcreate_u16(UINT64_C(0x905affffffff8000)),
                          vcreate_u16(UINT64_C(0x0000a250d8e47fff)));
      arg2 = vcombine_u16(vcreate_u16(UINT64_C(0x8000ffff7fff7fff)),
                          vcreate_u16(UINT64_C(0xffff80008000ffff)));
      clear_neon_saturated();
      //  Expect: "result" = 0000ffff00002250000058e400008000
      result = vabdl_high_u16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 0);
         exp = UINT64_C(0x000058e400008000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 1);
         exp = UINT64_C(0x0000ffff00002250);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_668() {

{
   {
      uint32x4_t arg1;
      uint32x4_t arg2;
      uint64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"abd\", fnname = \"vabdl_high_u32\", rettype = \"uint64x2_t\", argtypes = \"[uint32x4_t,uint32x4_t]\", vals = [VectorVal [IntegerVal 4294967295,IntegerVal 3705208832,IntegerVal 10376,IntegerVal 2147516415],VectorVal [IntegerVal 4294934527,IntegerVal 2147450880,IntegerVal 32767,IntegerVal 4294928756]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u32(vcreate_u32(UINT64_C(0xdcd90000ffffffff)),
                          vcreate_u32(UINT64_C(0x80007fff00002888)));
      arg2 = vcombine_u32(vcreate_u32(UINT64_C(0x7fff8000ffff7fff)),
                          vcreate_u32(UINT64_C(0xffff697400007fff)));
      clear_neon_saturated();
      //  Expect: "result" = 000000007ffee9750000000000005777
      result = vabdl_high_u32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 0);
         exp = UINT64_C(0x0000000000005777);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 1);
         exp = UINT64_C(0x000000007ffee975);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_669() {

{
   {
      int8x8_t arg1;
      int8x8_t arg2;
      int8x8_t arg3;
      int8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"aba\", fnname = \"vaba_s8\", rettype = \"int8x8_t\", argtypes = \"[int8x8_t,int8x8_t,int8x8_t]\", vals = [VectorVal [IntegerVal (-128),IntegerVal (-1),IntegerVal (-128),IntegerVal (-1),IntegerVal 127,IntegerVal 0,IntegerVal 127,IntegerVal (-80)],VectorVal [IntegerVal (-128),IntegerVal 127,IntegerVal (-128),IntegerVal (-1),IntegerVal (-1),IntegerVal (-53),IntegerVal 127,IntegerVal (-34)],VectorVal [IntegerVal (-1),IntegerVal (-128),IntegerVal (-2),IntegerVal 122,IntegerVal (-128),IntegerVal (-128),IntegerVal 0,IntegerVal 0]], start_saturated = True}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s8(UINT64_C(0xb07f007fff80ff80));
      arg2 = vcreate_s8(UINT64_C(0xde7fcbffff807f80));
      arg3 = vcreate_s8(UINT64_C(0x000080807afe80ff));
      set_neon_saturated();
      //  Expect: "result" = d2fe4bfe7afefeff
      result = vaba_s8(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s8(result), 0);
      exp = UINT64_C(0xd2fe4bfe7afefeff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_670() {

{
   {
      int16x4_t arg1;
      int16x4_t arg2;
      int16x4_t arg3;
      int16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"aba\", fnname = \"vaba_s16\", rettype = \"int16x4_t\", argtypes = \"[int16x4_t,int16x4_t,int16x4_t]\", vals = [VectorVal [IntegerVal 32767,IntegerVal 0,IntegerVal (-1),IntegerVal (-1)],VectorVal [IntegerVal 0,IntegerVal (-32768),IntegerVal (-1),IntegerVal 32767],VectorVal [IntegerVal 0,IntegerVal (-32768),IntegerVal (-1),IntegerVal (-1)]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s16(UINT64_C(0xffffffff00007fff));
      arg2 = vcreate_s16(UINT64_C(0x7fffffff80000000));
      arg3 = vcreate_s16(UINT64_C(0xffffffff80000000));
      clear_neon_saturated();
      //  Expect: "result" = 7fffffff00007fff
      result = vaba_s16(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s16(result), 0);
      exp = UINT64_C(0x7fffffff00007fff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_671() {

{
   {
      int32x2_t arg1;
      int32x2_t arg2;
      int32x2_t arg3;
      int32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"aba\", fnname = \"vaba_s32\", rettype = \"int32x2_t\", argtypes = \"[int32x2_t,int32x2_t,int32x2_t]\", vals = [VectorVal [IntegerVal 2147450880,IntegerVal 32767],VectorVal [IntegerVal (-2147471595),IntegerVal 1611792383],VectorVal [IntegerVal (-1),IntegerVal 32768]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s32(UINT64_C(0x00007fff7fff8000));
      arg2 = vcreate_s32(UINT64_C(0x6011ffff80002f15));
      arg3 = vcreate_s32(UINT64_C(0x00008000ffffffff));
      clear_neon_saturated();
      //  Expect: "result" = 6011fffeffff50ea
      result = vaba_s32(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s32(result), 0);
      exp = UINT64_C(0x6011fffeffff50ea);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_672() {

{
   {
      uint8x8_t arg1;
      uint8x8_t arg2;
      uint8x8_t arg3;
      uint8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"aba\", fnname = \"vaba_u8\", rettype = \"uint8x8_t\", argtypes = \"[uint8x8_t,uint8x8_t,uint8x8_t]\", vals = [VectorVal [IntegerVal 124,IntegerVal 255,IntegerVal 255,IntegerVal 0,IntegerVal 0,IntegerVal 87,IntegerVal 0,IntegerVal 128],VectorVal [IntegerVal 128,IntegerVal 127,IntegerVal 255,IntegerVal 255,IntegerVal 255,IntegerVal 158,IntegerVal 255,IntegerVal 128],VectorVal [IntegerVal 157,IntegerVal 255,IntegerVal 255,IntegerVal 128,IntegerVal 225,IntegerVal 127,IntegerVal 128,IntegerVal 0]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u8(UINT64_C(0x8000570000ffff7c));
      arg2 = vcreate_u8(UINT64_C(0x80ff9effffff7f80));
      arg3 = vcreate_u8(UINT64_C(0x00807fe180ffff9d));
      clear_neon_saturated();
      //  Expect: "result" = 007f761e7fff7f99
      result = vaba_u8(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u8(result), 0);
      exp = UINT64_C(0x007f761e7fff7f99);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_673() {

{
   {
      uint16x4_t arg1;
      uint16x4_t arg2;
      uint16x4_t arg3;
      uint16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"aba\", fnname = \"vaba_u16\", rettype = \"uint16x4_t\", argtypes = \"[uint16x4_t,uint16x4_t,uint16x4_t]\", vals = [VectorVal [IntegerVal 65535,IntegerVal 65535,IntegerVal 0,IntegerVal 32767],VectorVal [IntegerVal 32767,IntegerVal 32768,IntegerVal 32768,IntegerVal 65535],VectorVal [IntegerVal 32768,IntegerVal 65535,IntegerVal 0,IntegerVal 46851]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u16(UINT64_C(0x7fff0000ffffffff));
      arg2 = vcreate_u16(UINT64_C(0xffff800080007fff));
      arg3 = vcreate_u16(UINT64_C(0xb7030000ffff8000));
      clear_neon_saturated();
      //  Expect: "result" = c8fb80007ffe0000
      result = vaba_u16(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u16(result), 0);
      exp = UINT64_C(0xc8fb80007ffe0000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_674() {

{
   {
      uint32x2_t arg1;
      uint32x2_t arg2;
      uint32x2_t arg3;
      uint32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"aba\", fnname = \"vaba_u32\", rettype = \"uint32x2_t\", argtypes = \"[uint32x2_t,uint32x2_t,uint32x2_t]\", vals = [VectorVal [IntegerVal 2147450880,IntegerVal 2014281728],VectorVal [IntegerVal 2147483648,IntegerVal 4294967295],VectorVal [IntegerVal 2147483648,IntegerVal 2147516416]], start_saturated = True}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u32(UINT64_C(0x780f80007fff8000));
      arg2 = vcreate_u32(UINT64_C(0xffffffff80000000));
      arg3 = vcreate_u32(UINT64_C(0x8000800080000000));
      set_neon_saturated();
      //  Expect: "result" = f80effff7fff8000
      result = vaba_u32(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u32(result), 0);
      exp = UINT64_C(0xf80effff7fff8000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_675() {

{
   {
      int8x16_t arg1;
      int8x16_t arg2;
      int8x16_t arg3;
      int8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"aba\", fnname = \"vabaq_s8\", rettype = \"int8x16_t\", argtypes = \"[int8x16_t,int8x16_t,int8x16_t]\", vals = [VectorVal [IntegerVal (-89),IntegerVal 127,IntegerVal 94,IntegerVal 0,IntegerVal 0,IntegerVal 127,IntegerVal (-1),IntegerVal (-1),IntegerVal 0,IntegerVal (-77),IntegerVal (-128),IntegerVal 0,IntegerVal 127,IntegerVal (-61),IntegerVal 0,IntegerVal (-128)],VectorVal [IntegerVal (-1),IntegerVal (-1),IntegerVal (-1),IntegerVal 0,IntegerVal (-128),IntegerVal 0,IntegerVal (-18),IntegerVal 0,IntegerVal 0,IntegerVal 127,IntegerVal (-1),IntegerVal (-1),IntegerVal 0,IntegerVal (-128),IntegerVal 127,IntegerVal 10],VectorVal [IntegerVal (-1),IntegerVal 0,IntegerVal (-128),IntegerVal (-128),IntegerVal (-128),IntegerVal (-117),IntegerVal 20,IntegerVal (-128),IntegerVal 127,IntegerVal (-74),IntegerVal (-1),IntegerVal (-1),IntegerVal (-104),IntegerVal (-128),IntegerVal 0,IntegerVal 127]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s8(vcreate_s8(UINT64_C(0xffff7f00005e7fa7)),
                         vcreate_s8(UINT64_C(0x8000c37f0080b300)));
      arg2 = vcombine_s8(vcreate_s8(UINT64_C(0x00ee008000ffffff)),
                         vcreate_s8(UINT64_C(0x0a7f8000ffff7f00)));
      arg3 = vcombine_s8(vcreate_s8(UINT64_C(0x80148b80808000ff)),
                         vcreate_s8(UINT64_C(0x7f008098ffffb67f)));
      clear_neon_saturated();
      //  Expect: "result" = f57fc3e700807c7f7f25f40080dd80a7
      result = vabaq_s8(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result), 0);
         exp = UINT64_C(0x7f25f40080dd80a7);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result), 1);
         exp = UINT64_C(0xf57fc3e700807c7f);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_676() {

{
   {
      int16x8_t arg1;
      int16x8_t arg2;
      int16x8_t arg3;
      int16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"aba\", fnname = \"vabaq_s16\", rettype = \"int16x8_t\", argtypes = \"[int16x8_t,int16x8_t,int16x8_t]\", vals = [VectorVal [IntegerVal (-17734),IntegerVal (-23081),IntegerVal 0,IntegerVal (-1),IntegerVal (-1),IntegerVal 32767,IntegerVal 15977,IntegerVal (-9559)],VectorVal [IntegerVal 0,IntegerVal (-32768),IntegerVal (-32768),IntegerVal 32767,IntegerVal 32767,IntegerVal (-1),IntegerVal 32767,IntegerVal 0],VectorVal [IntegerVal 0,IntegerVal 24780,IntegerVal 9947,IntegerVal (-32768),IntegerVal (-32768),IntegerVal (-12661),IntegerVal 0,IntegerVal (-32768)]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s16(vcreate_s16(UINT64_C(0xffff0000a5d7baba)),
                          vcreate_s16(UINT64_C(0xdaa93e697fffffff)));
      arg2 = vcombine_s16(vcreate_s16(UINT64_C(0x7fff800080000000)),
                          vcreate_s16(UINT64_C(0x00007fffffff7fff)));
      arg3 = vcombine_s16(vcreate_s16(UINT64_C(0x800026db60cc0000)),
                          vcreate_s16(UINT64_C(0x80000000ce8b8000)));
      clear_neon_saturated();
      //  Expect: "result" = 5aa9be68b173fffefffea6db86a3baba
      result = vabaq_s16(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 0);
         exp = UINT64_C(0xfffea6db86a3baba);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 1);
         exp = UINT64_C(0x5aa9be68b173fffe);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_677() {

{
   {
      int32x4_t arg1;
      int32x4_t arg2;
      int32x4_t arg3;
      int32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"aba\", fnname = \"vabaq_s32\", rettype = \"int32x4_t\", argtypes = \"[int32x4_t,int32x4_t,int32x4_t]\", vals = [VectorVal [IntegerVal (-2147483648),IntegerVal 1451242912,IntegerVal 1250838605,IntegerVal (-1255079936)],VectorVal [IntegerVal (-1139638272),IntegerVal (-1),IntegerVal 2147450880,IntegerVal (-2147418113)],VectorVal [IntegerVal 0,IntegerVal 37625,IntegerVal (-32769),IntegerVal 2065039359]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s32(vcreate_s32(UINT64_C(0x568035a080000000)),
                          vcreate_s32(UINT64_C(0xb53100004a8e484d)));
      arg2 = vcombine_s32(vcreate_s32(UINT64_C(0xffffffffbc128000)),
                          vcreate_s32(UINT64_C(0x8000ffff7fff8000)));
      arg3 = vcombine_s32(vcreate_s32(UINT64_C(0x000092f900000000)),
                          vcreate_s32(UINT64_C(0x7b15ffffffff7fff)));
      clear_neon_saturated();
      //  Expect: "result" = b0460000ca8e484e5680c89ac3ed8000
      result = vabaq_s32(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 0);
         exp = UINT64_C(0x5680c89ac3ed8000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 1);
         exp = UINT64_C(0xb0460000ca8e484e);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_678() {

{
   {
      uint8x16_t arg1;
      uint8x16_t arg2;
      uint8x16_t arg3;
      uint8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"aba\", fnname = \"vabaq_u8\", rettype = \"uint8x16_t\", argtypes = \"[uint8x16_t,uint8x16_t,uint8x16_t]\", vals = [VectorVal [IntegerVal 128,IntegerVal 255,IntegerVal 128,IntegerVal 255,IntegerVal 255,IntegerVal 0,IntegerVal 128,IntegerVal 255,IntegerVal 128,IntegerVal 128,IntegerVal 250,IntegerVal 128,IntegerVal 127,IntegerVal 255,IntegerVal 0,IntegerVal 128],VectorVal [IntegerVal 215,IntegerVal 128,IntegerVal 127,IntegerVal 0,IntegerVal 29,IntegerVal 127,IntegerVal 127,IntegerVal 0,IntegerVal 0,IntegerVal 255,IntegerVal 127,IntegerVal 95,IntegerVal 127,IntegerVal 128,IntegerVal 0,IntegerVal 0],VectorVal [IntegerVal 255,IntegerVal 127,IntegerVal 55,IntegerVal 0,IntegerVal 85,IntegerVal 127,IntegerVal 0,IntegerVal 111,IntegerVal 127,IntegerVal 127,IntegerVal 255,IntegerVal 0,IntegerVal 128,IntegerVal 0,IntegerVal 128,IntegerVal 127]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u8(vcreate_u8(UINT64_C(0xff8000ffff80ff80)),
                         vcreate_u8(UINT64_C(0x8000ff7f80fa8080)));
      arg2 = vcombine_u8(vcreate_u8(UINT64_C(0x007f7f1d007f80d7)),
                         vcreate_u8(UINT64_C(0x0000807f5f7fff00)));
      arg3 = vcombine_u8(vcreate_u8(UINT64_C(0x6f007f5500377fff)),
                         vcreate_u8(UINT64_C(0x7f80008000ff7f7f)));
      clear_neon_saturated();
      //  Expect: "result" = ff807f80df7a00ff6eff0037ffc800a8
      result = vabaq_u8(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 0);
         exp = UINT64_C(0x6eff0037ffc800a8);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 1);
         exp = UINT64_C(0xff807f80df7a00ff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_679() {

{
   {
      uint16x8_t arg1;
      uint16x8_t arg2;
      uint16x8_t arg3;
      uint16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"aba\", fnname = \"vabaq_u16\", rettype = \"uint16x8_t\", argtypes = \"[uint16x8_t,uint16x8_t,uint16x8_t]\", vals = [VectorVal [IntegerVal 0,IntegerVal 65535,IntegerVal 2315,IntegerVal 36325,IntegerVal 32767,IntegerVal 32767,IntegerVal 0,IntegerVal 32767],VectorVal [IntegerVal 65535,IntegerVal 32768,IntegerVal 48021,IntegerVal 34267,IntegerVal 32767,IntegerVal 32768,IntegerVal 65535,IntegerVal 17590],VectorVal [IntegerVal 32768,IntegerVal 25944,IntegerVal 32767,IntegerVal 32768,IntegerVal 32767,IntegerVal 32767,IntegerVal 62217,IntegerVal 32767]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u16(vcreate_u16(UINT64_C(0x8de5090bffff0000)),
                          vcreate_u16(UINT64_C(0x7fff00007fff7fff)));
      arg2 = vcombine_u16(vcreate_u16(UINT64_C(0x85dbbb958000ffff)),
                          vcreate_u16(UINT64_C(0x44b6ffff80007fff)));
      arg3 = vcombine_u16(vcreate_u16(UINT64_C(0x80007fff65588000)),
                          vcreate_u16(UINT64_C(0x7ffff3097fff7fff)));
      clear_neon_saturated();
      //  Expect: "result" = bb480cf680007fff93c044a11aa77fff
      result = vabaq_u16(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 0);
         exp = UINT64_C(0x93c044a11aa77fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 1);
         exp = UINT64_C(0xbb480cf680007fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_680() {

{
   {
      uint32x4_t arg1;
      uint32x4_t arg2;
      uint32x4_t arg3;
      uint32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"aba\", fnname = \"vabaq_u32\", rettype = \"uint32x4_t\", argtypes = \"[uint32x4_t,uint32x4_t,uint32x4_t]\", vals = [VectorVal [IntegerVal 4294934527,IntegerVal 2147516416,IntegerVal 32767,IntegerVal 32768],VectorVal [IntegerVal 1484226560,IntegerVal 65535,IntegerVal 2070315008,IntegerVal 3052171458],VectorVal [IntegerVal 4294901760,IntegerVal 32767,IntegerVal 32767,IntegerVal 2147418112]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u32(vcreate_u32(UINT64_C(0x80008000ffff7fff)),
                          vcreate_u32(UINT64_C(0x0000800000007fff)));
      arg2 = vcombine_u32(vcreate_u32(UINT64_C(0x0000ffff58778000)),
                          vcreate_u32(UINT64_C(0xb5ec70c27b668000)));
      arg3 = vcombine_u32(vcreate_u32(UINT64_C(0x00007fffffff0000)),
                          vcreate_u32(UINT64_C(0x7fff000000007fff)));
      clear_neon_saturated();
      //  Expect: "result" = 35edf0c27b66800080010000a786ffff
      result = vabaq_u32(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 0);
         exp = UINT64_C(0x80010000a786ffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 1);
         exp = UINT64_C(0x35edf0c27b668000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_681() {

{
   {
      int16x8_t arg1;
      int8x8_t arg2;
      int8x8_t arg3;
      int16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"aba\", fnname = \"vabal_s8\", rettype = \"int16x8_t\", argtypes = \"[int16x8_t,int8x8_t,int8x8_t]\", vals = [VectorVal [IntegerVal (-1955),IntegerVal 32767,IntegerVal (-4058),IntegerVal 0,IntegerVal 2952,IntegerVal 0,IntegerVal (-32768),IntegerVal 28416],VectorVal [IntegerVal (-128),IntegerVal (-128),IntegerVal (-128),IntegerVal (-128),IntegerVal (-1),IntegerVal (-1),IntegerVal (-67),IntegerVal (-128)],VectorVal [IntegerVal (-128),IntegerVal (-35),IntegerVal 76,IntegerVal (-86),IntegerVal 8,IntegerVal (-38),IntegerVal (-128),IntegerVal (-128)]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s16(vcreate_s16(UINT64_C(0x0000f0267ffff85d)),
                          vcreate_s16(UINT64_C(0x6f00800000000b88)));
      arg2 = vcreate_s8(UINT64_C(0x80bdffff80808080));
      arg3 = vcreate_s8(UINT64_C(0x8080da08aa4cdd80));
      clear_neon_saturated();
      //  Expect: "result" = 6f00803d00250b91002af0f2805cf85d
      result = vabal_s8(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 0);
         exp = UINT64_C(0x002af0f2805cf85d);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 1);
         exp = UINT64_C(0x6f00803d00250b91);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_682() {

{
   {
      int32x4_t arg1;
      int16x4_t arg2;
      int16x4_t arg3;
      int32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"aba\", fnname = \"vabal_s16\", rettype = \"int32x4_t\", argtypes = \"[int32x4_t,int16x4_t,int16x4_t]\", vals = [VectorVal [IntegerVal (-1),IntegerVal 0,IntegerVal (-2147450881),IntegerVal 2147450880],VectorVal [IntegerVal 0,IntegerVal (-1),IntegerVal 32767,IntegerVal 32767],VectorVal [IntegerVal 0,IntegerVal 8161,IntegerVal (-30696),IntegerVal 0]], start_saturated = True}";
      int reported = 0;
      arg1 = vcombine_s32(vcreate_s32(UINT64_C(0x00000000ffffffff)),
                          vcreate_s32(UINT64_C(0x7fff800080007fff)));
      arg2 = vcreate_s16(UINT64_C(0x7fff7fffffff0000));
      arg3 = vcreate_s16(UINT64_C(0x000088181fe10000));
      set_neon_saturated();
      //  Expect: "result" = 7fffffff800177e600001fe2ffffffff
      result = vabal_s16(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 0);
         exp = UINT64_C(0x00001fe2ffffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 1);
         exp = UINT64_C(0x7fffffff800177e6);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_683() {

{
   {
      int64x2_t arg1;
      int32x2_t arg2;
      int32x2_t arg3;
      int64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"aba\", fnname = \"vabal_s32\", rettype = \"int64x2_t\", argtypes = \"[int64x2_t,int32x2_t,int32x2_t]\", vals = [VectorVal [IntegerVal (-140735340838913),IntegerVal 9223231302035472384],VectorVal [IntegerVal 65535,IntegerVal (-2059337728)],VectorVal [IntegerVal 2147450879,IntegerVal (-2147450880)]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s64(vcreate_s64(UINT64_C(0xffff800080007fff)),
                          vcreate_s64(UINT64_C(0x7fff80009f168000)));
      arg2 = vcreate_s32(UINT64_C(0x854100000000ffff));
      arg3 = vcreate_s32(UINT64_C(0x800080007fff7fff));
      clear_neon_saturated();
      //  Expect: "result" = 7fff8000a4570000ffff8000fffeffff
      result = vabal_s32(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 0);
         exp = UINT64_C(0xffff8000fffeffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 1);
         exp = UINT64_C(0x7fff8000a4570000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_684() {

{
   {
      uint16x8_t arg1;
      uint8x8_t arg2;
      uint8x8_t arg3;
      uint16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"aba\", fnname = \"vabal_u8\", rettype = \"uint16x8_t\", argtypes = \"[uint16x8_t,uint8x8_t,uint8x8_t]\", vals = [VectorVal [IntegerVal 0,IntegerVal 32767,IntegerVal 32767,IntegerVal 32768,IntegerVal 65535,IntegerVal 0,IntegerVal 0,IntegerVal 32768],VectorVal [IntegerVal 128,IntegerVal 33,IntegerVal 0,IntegerVal 127,IntegerVal 79,IntegerVal 76,IntegerVal 0,IntegerVal 0],VectorVal [IntegerVal 0,IntegerVal 0,IntegerVal 127,IntegerVal 127,IntegerVal 133,IntegerVal 0,IntegerVal 200,IntegerVal 0]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u16(vcreate_u16(UINT64_C(0x80007fff7fff0000)),
                          vcreate_u16(UINT64_C(0x800000000000ffff)));
      arg2 = vcreate_u8(UINT64_C(0x00004c4f7f002180));
      arg3 = vcreate_u8(UINT64_C(0x00c800857f7f0000));
      clear_neon_saturated();
      //  Expect: "result" = 800000c8004c00358000807e80200080
      result = vabal_u8(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 0);
         exp = UINT64_C(0x8000807e80200080);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 1);
         exp = UINT64_C(0x800000c8004c0035);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_685() {

{
   {
      uint32x4_t arg1;
      uint16x4_t arg2;
      uint16x4_t arg3;
      uint32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"aba\", fnname = \"vabal_u16\", rettype = \"uint32x4_t\", argtypes = \"[uint32x4_t,uint16x4_t,uint16x4_t]\", vals = [VectorVal [IntegerVal 4294934528,IntegerVal 2147549183,IntegerVal 2147516415,IntegerVal 3375124769],VectorVal [IntegerVal 65535,IntegerVal 32767,IntegerVal 32768,IntegerVal 32767],VectorVal [IntegerVal 32768,IntegerVal 65535,IntegerVal 58900,IntegerVal 23049]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u32(vcreate_u32(UINT64_C(0x8000ffffffff8000)),
                          vcreate_u32(UINT64_C(0xc92c512180007fff)));
      arg2 = vcreate_u16(UINT64_C(0x7fff80007fffffff));
      arg3 = vcreate_u16(UINT64_C(0x5a09e614ffff8000));
      clear_neon_saturated();
      //  Expect: "result" = c92c77178000e61380017fffffffffff
      result = vabal_u16(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 0);
         exp = UINT64_C(0x80017fffffffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 1);
         exp = UINT64_C(0xc92c77178000e613);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_686() {

{
   {
      uint64x2_t arg1;
      uint32x2_t arg2;
      uint32x2_t arg3;
      uint64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"aba\", fnname = \"vabal_u32\", rettype = \"uint64x2_t\", argtypes = \"[uint64x2_t,uint32x2_t,uint32x2_t]\", vals = [VectorVal [IntegerVal 281474976677888,IntegerVal 4294939138],VectorVal [IntegerVal 32768,IntegerVal 2147473523],VectorVal [IntegerVal 2147432327,IntegerVal 1697382399]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u64(vcreate_u64(UINT64_C(0x0000ffffffff8000)),
                          vcreate_u64(UINT64_C(0x00000000ffff9202)));
      arg2 = vcreate_u32(UINT64_C(0x7fffd87300008000));
      arg3 = vcreate_u32(UINT64_C(0x652bffff7fff3787));
      clear_neon_saturated();
      //  Expect: "result" = 000000011ad36a76000100007ffe3787
      result = vabal_u32(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 0);
         exp = UINT64_C(0x000100007ffe3787);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 1);
         exp = UINT64_C(0x000000011ad36a76);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_687() {

{
   {
      int16x8_t arg1;
      int8x16_t arg2;
      int8x16_t arg3;
      int16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"aba\", fnname = \"vabal_high_s8\", rettype = \"int16x8_t\", argtypes = \"[int16x8_t,int8x16_t,int8x16_t]\", vals = [VectorVal [IntegerVal (-1),IntegerVal (-32768),IntegerVal (-32326),IntegerVal (-32768),IntegerVal (-1),IntegerVal 32767,IntegerVal 0,IntegerVal (-1)],VectorVal [IntegerVal 127,IntegerVal (-1),IntegerVal (-33),IntegerVal (-1),IntegerVal 0,IntegerVal (-128),IntegerVal (-128),IntegerVal 127,IntegerVal 125,IntegerVal 0,IntegerVal 16,IntegerVal 20,IntegerVal (-53),IntegerVal (-128),IntegerVal 0,IntegerVal 0],VectorVal [IntegerVal 127,IntegerVal (-128),IntegerVal (-128),IntegerVal (-1),IntegerVal (-91),IntegerVal 127,IntegerVal (-62),IntegerVal (-1),IntegerVal (-1),IntegerVal (-128),IntegerVal (-1),IntegerVal (-128),IntegerVal (-71),IntegerVal 0,IntegerVal (-1),IntegerVal 0]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s16(vcreate_s16(UINT64_C(0x800081ba8000ffff)),
                          vcreate_s16(UINT64_C(0xffff00007fffffff)));
      arg2 = vcombine_s8(vcreate_s8(UINT64_C(0x7f808000ffdfff7f)),
                         vcreate_s8(UINT64_C(0x000080cb1410007d)));
      arg3 = vcombine_s8(vcreate_s8(UINT64_C(0xffc27fa5ff80807f)),
                         vcreate_s8(UINT64_C(0x00ff00b980ff80ff)));
      clear_neon_saturated();
      //  Expect: "result" = ffff0001807f0011809481cb8080007d
      result = vabal_high_s8(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 0);
         exp = UINT64_C(0x809481cb8080007d);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 1);
         exp = UINT64_C(0xffff0001807f0011);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_688() {

{
   {
      int32x4_t arg1;
      int16x8_t arg2;
      int16x8_t arg3;
      int32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"aba\", fnname = \"vabal_high_s16\", rettype = \"int32x4_t\", argtypes = \"[int32x4_t,int16x8_t,int16x8_t]\", vals = [VectorVal [IntegerVal 2147418112,IntegerVal (-2147483648),IntegerVal (-2147454935),IntegerVal (-2147450881)],VectorVal [IntegerVal 32767,IntegerVal 8259,IntegerVal (-32768),IntegerVal 0,IntegerVal 32767,IntegerVal 32767,IntegerVal 32767,IntegerVal 32767],VectorVal [IntegerVal (-1),IntegerVal (-1),IntegerVal 0,IntegerVal (-32768),IntegerVal 32767,IntegerVal 0,IntegerVal 7265,IntegerVal 0]], start_saturated = True}";
      int reported = 0;
      arg1 = vcombine_s32(vcreate_s32(UINT64_C(0x800000007fff0000)),
                          vcreate_s32(UINT64_C(0x80007fff80007029)));
      arg2 = vcombine_s16(vcreate_s16(UINT64_C(0x0000800020437fff)),
                          vcreate_s16(UINT64_C(0x7fff7fff7fff7fff)));
      arg3 = vcombine_s16(vcreate_s16(UINT64_C(0x80000000ffffffff)),
                          vcreate_s16(UINT64_C(0x00001c6100007fff)));
      set_neon_saturated();
      //  Expect: "result" = 8000fffe8000d3c780007fff7fff0000
      result = vabal_high_s16(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 0);
         exp = UINT64_C(0x80007fff7fff0000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 1);
         exp = UINT64_C(0x8000fffe8000d3c7);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_689() {

{
   {
      int64x2_t arg1;
      int32x4_t arg2;
      int32x4_t arg3;
      int64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"aba\", fnname = \"vabal_high_s32\", rettype = \"int64x2_t\", argtypes = \"[int64x2_t,int32x4_t,int32x4_t]\", vals = [VectorVal [IntegerVal 9223372034707324928,IntegerVal (-140733193420800)],VectorVal [IntegerVal (-29370),IntegerVal (-2147483648),IntegerVal 2147483647,IntegerVal (-32768)],VectorVal [IntegerVal (-1),IntegerVal (-65536),IntegerVal 65535,IntegerVal 65535]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s64(vcreate_s64(UINT64_C(0x7fffffff80008000)),
                          vcreate_s64(UINT64_C(0xffff8000ffff8000)));
      arg2 = vcombine_s32(vcreate_s32(UINT64_C(0x80000000ffff8d46)),
                          vcreate_s32(UINT64_C(0xffff80007fffffff)));
      arg3 = vcombine_s32(vcreate_s32(UINT64_C(0xffff0000ffffffff)),
                          vcreate_s32(UINT64_C(0x0000ffff0000ffff)));
      clear_neon_saturated();
      //  Expect: "result" = ffff80010000ffff7fffffffffff8000
      result = vabal_high_s32(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 0);
         exp = UINT64_C(0x7fffffffffff8000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 1);
         exp = UINT64_C(0xffff80010000ffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_690() {

{
   {
      uint16x8_t arg1;
      uint8x16_t arg2;
      uint8x16_t arg3;
      uint16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"aba\", fnname = \"vabal_high_u8\", rettype = \"uint16x8_t\", argtypes = \"[uint16x8_t,uint8x16_t,uint8x16_t]\", vals = [VectorVal [IntegerVal 65535,IntegerVal 32767,IntegerVal 0,IntegerVal 32767,IntegerVal 32768,IntegerVal 53020,IntegerVal 32768,IntegerVal 46960],VectorVal [IntegerVal 128,IntegerVal 0,IntegerVal 128,IntegerVal 127,IntegerVal 255,IntegerVal 127,IntegerVal 0,IntegerVal 117,IntegerVal 57,IntegerVal 127,IntegerVal 0,IntegerVal 0,IntegerVal 127,IntegerVal 255,IntegerVal 127,IntegerVal 0],VectorVal [IntegerVal 128,IntegerVal 255,IntegerVal 128,IntegerVal 128,IntegerVal 127,IntegerVal 127,IntegerVal 255,IntegerVal 210,IntegerVal 127,IntegerVal 255,IntegerVal 128,IntegerVal 127,IntegerVal 127,IntegerVal 128,IntegerVal 255,IntegerVal 7]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u16(vcreate_u16(UINT64_C(0x7fff00007fffffff)),
                          vcreate_u16(UINT64_C(0xb7708000cf1c8000)));
      arg2 = vcombine_u8(vcreate_u8(UINT64_C(0x75007fff7f800080)),
                         vcreate_u8(UINT64_C(0x007fff7f00007f39)));
      arg3 = vcombine_u8(vcreate_u8(UINT64_C(0xd2ff7f7f8080ff80)),
                         vcreate_u8(UINT64_C(0x07ff807f7f80ff7f)));
      clear_neon_saturated();
      //  Expect: "result" = b7778080cf9b8000807e0080807f0045
      result = vabal_high_u8(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 0);
         exp = UINT64_C(0x807e0080807f0045);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 1);
         exp = UINT64_C(0xb7778080cf9b8000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_691() {

{
   {
      uint32x4_t arg1;
      uint16x8_t arg2;
      uint16x8_t arg3;
      uint32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"aba\", fnname = \"vabal_high_u16\", rettype = \"uint32x4_t\", argtypes = \"[uint32x4_t,uint16x8_t,uint16x8_t]\", vals = [VectorVal [IntegerVal 65535,IntegerVal 2147516415,IntegerVal 2147450879,IntegerVal 2147418112],VectorVal [IntegerVal 65535,IntegerVal 32767,IntegerVal 65535,IntegerVal 0,IntegerVal 32767,IntegerVal 32768,IntegerVal 0,IntegerVal 32768],VectorVal [IntegerVal 32767,IntegerVal 32768,IntegerVal 32768,IntegerVal 0,IntegerVal 0,IntegerVal 48033,IntegerVal 65535,IntegerVal 0]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u32(vcreate_u32(UINT64_C(0x80007fff0000ffff)),
                          vcreate_u32(UINT64_C(0x7fff00007fff7fff)));
      arg2 = vcombine_u16(vcreate_u16(UINT64_C(0x0000ffff7fffffff)),
                          vcreate_u16(UINT64_C(0x8000000080007fff)));
      arg3 = vcombine_u16(vcreate_u16(UINT64_C(0x0000800080007fff)),
                          vcreate_u16(UINT64_C(0x0000ffffbba10000)));
      clear_neon_saturated();
      //  Expect: "result" = 7fff800080007ffe8000bba000017ffe
      result = vabal_high_u16(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 0);
         exp = UINT64_C(0x8000bba000017ffe);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 1);
         exp = UINT64_C(0x7fff800080007ffe);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_692() {

{
   {
      uint64x2_t arg1;
      uint32x4_t arg2;
      uint32x4_t arg3;
      uint64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"aba\", fnname = \"vabal_high_u32\", rettype = \"uint64x2_t\", argtypes = \"[uint64x2_t,uint32x4_t,uint32x4_t]\", vals = [VectorVal [IntegerVal 160655399124992,IntegerVal 140735340904448],VectorVal [IntegerVal 2147483648,IntegerVal 3960504320,IntegerVal 2147516416,IntegerVal 2147501501],VectorVal [IntegerVal 932052991,IntegerVal 32768,IntegerVal 16242,IntegerVal 2147496051]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u64(vcreate_u64(UINT64_C(0x0000921d7fff0000)),
                          vcreate_u64(UINT64_C(0x00007fff80008000)));
      arg2 = vcombine_u32(vcreate_u32(UINT64_C(0xec10800080000000)),
                          vcreate_u32(UINT64_C(0x800045bd80008000)));
      arg3 = vcombine_u32(vcreate_u32(UINT64_C(0x00008000378dffff)),
                          vcreate_u32(UINT64_C(0x8000307300003f72)));
      clear_neon_saturated();
      //  Expect: "result" = 00007fff8000954a0000921dffff408e
      result = vabal_high_u32(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 0);
         exp = UINT64_C(0x0000921dffff408e);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 1);
         exp = UINT64_C(0x00007fff8000954a);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_693() {

{
   {
      int8x8_t arg1;
      int8x8_t arg2;
      int8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"max\", fnname = \"vmax_s8\", rettype = \"int8x8_t\", argtypes = \"[int8x8_t,int8x8_t]\", vals = [VectorVal [IntegerVal (-128),IntegerVal 72,IntegerVal (-128),IntegerVal (-1),IntegerVal 127,IntegerVal 0,IntegerVal 0,IntegerVal (-128)],VectorVal [IntegerVal (-44),IntegerVal 127,IntegerVal (-128),IntegerVal (-128),IntegerVal (-1),IntegerVal (-1),IntegerVal (-128),IntegerVal (-128)]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s8(UINT64_C(0x8000007fff804880));
      arg2 = vcreate_s8(UINT64_C(0x8080ffff80807fd4));
      clear_neon_saturated();
      //  Expect: "result" = 8000007fff807fd4
      result = vmax_s8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s8(result), 0);
      exp = UINT64_C(0x8000007fff807fd4);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_694() {

{
   {
      int16x4_t arg1;
      int16x4_t arg2;
      int16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"max\", fnname = \"vmax_s16\", rettype = \"int16x4_t\", argtypes = \"[int16x4_t,int16x4_t]\", vals = [VectorVal [IntegerVal (-32768),IntegerVal 32767,IntegerVal (-26676),IntegerVal 0],VectorVal [IntegerVal 32767,IntegerVal (-32768),IntegerVal 0,IntegerVal (-1)]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s16(UINT64_C(0x000097cc7fff8000));
      arg2 = vcreate_s16(UINT64_C(0xffff000080007fff));
      clear_neon_saturated();
      //  Expect: "result" = 000000007fff7fff
      result = vmax_s16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s16(result), 0);
      exp = UINT64_C(0x000000007fff7fff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_695() {

{
   {
      int32x2_t arg1;
      int32x2_t arg2;
      int32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"max\", fnname = \"vmax_s32\", rettype = \"int32x2_t\", argtypes = \"[int32x2_t,int32x2_t]\", vals = [VectorVal [IntegerVal 2147481320,IntegerVal 2147450879],VectorVal [IntegerVal (-2147450880),IntegerVal (-2147450881)]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s32(UINT64_C(0x7fff7fff7ffff6e8));
      arg2 = vcreate_s32(UINT64_C(0x80007fff80008000));
      clear_neon_saturated();
      //  Expect: "result" = 7fff7fff7ffff6e8
      result = vmax_s32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s32(result), 0);
      exp = UINT64_C(0x7fff7fff7ffff6e8);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_696() {

{
   {
      uint8x8_t arg1;
      uint8x8_t arg2;
      uint8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"max\", fnname = \"vmax_u8\", rettype = \"uint8x8_t\", argtypes = \"[uint8x8_t,uint8x8_t]\", vals = [VectorVal [IntegerVal 127,IntegerVal 0,IntegerVal 127,IntegerVal 128,IntegerVal 128,IntegerVal 101,IntegerVal 0,IntegerVal 255],VectorVal [IntegerVal 127,IntegerVal 255,IntegerVal 128,IntegerVal 127,IntegerVal 243,IntegerVal 181,IntegerVal 255,IntegerVal 128]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u8(UINT64_C(0xff006580807f007f));
      arg2 = vcreate_u8(UINT64_C(0x80ffb5f37f80ff7f));
      clear_neon_saturated();
      //  Expect: "result" = ffffb5f38080ff7f
      result = vmax_u8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u8(result), 0);
      exp = UINT64_C(0xffffb5f38080ff7f);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_697() {

{
   {
      uint16x4_t arg1;
      uint16x4_t arg2;
      uint16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"max\", fnname = \"vmax_u16\", rettype = \"uint16x4_t\", argtypes = \"[uint16x4_t,uint16x4_t]\", vals = [VectorVal [IntegerVal 32767,IntegerVal 32767,IntegerVal 32767,IntegerVal 32767],VectorVal [IntegerVal 32768,IntegerVal 32767,IntegerVal 32767,IntegerVal 65535]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u16(UINT64_C(0x7fff7fff7fff7fff));
      arg2 = vcreate_u16(UINT64_C(0xffff7fff7fff8000));
      clear_neon_saturated();
      //  Expect: "result" = ffff7fff7fff8000
      result = vmax_u16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u16(result), 0);
      exp = UINT64_C(0xffff7fff7fff8000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_698() {

{
   {
      uint32x2_t arg1;
      uint32x2_t arg2;
      uint32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"max\", fnname = \"vmax_u32\", rettype = \"uint32x2_t\", argtypes = \"[uint32x2_t,uint32x2_t]\", vals = [VectorVal [IntegerVal 2147418112,IntegerVal 2147470802],VectorVal [IntegerVal 4294901760,IntegerVal 65535]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u32(UINT64_C(0x7fffcdd27fff0000));
      arg2 = vcreate_u32(UINT64_C(0x0000ffffffff0000));
      clear_neon_saturated();
      //  Expect: "result" = 7fffcdd2ffff0000
      result = vmax_u32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u32(result), 0);
      exp = UINT64_C(0x7fffcdd2ffff0000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_699() {

{
   {
      float32x2_t arg1;
      float32x2_t arg2;
      float32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"max\", fnname = \"vmax_f32\", rettype = \"float32x2_t\", argtypes = \"[float32x2_t,float32x2_t]\", vals = [VectorVal [FloatVal 0.554344654083252,FloatVal 0.5623960494995117],VectorVal [FloatVal 0.4630889296531677,FloatVal 0.5784722566604614]], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_f32(UINT64_C(0x3f0ff9303f0de988));
      arg2 = vcreate_f32(UINT64_C(0x3f1416c23eed19fe));
      clear_neon_saturated();
      //  Expect: "result" = 3f1416c23f0de988
      result = vmax_f32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result, 0);
         exp = ((float32_t) 0.554344654083252);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result, 1);
         exp = ((float32_t) 0.5784722566604614);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
   }
}
}
void dotests_700() {

{
   {
      int8x16_t arg1;
      int8x16_t arg2;
      int8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"max\", fnname = \"vmaxq_s8\", rettype = \"int8x16_t\", argtypes = \"[int8x16_t,int8x16_t]\", vals = [VectorVal [IntegerVal 0,IntegerVal 127,IntegerVal 127,IntegerVal (-1),IntegerVal 75,IntegerVal 0,IntegerVal (-1),IntegerVal 127,IntegerVal (-1),IntegerVal 0,IntegerVal (-1),IntegerVal 127,IntegerVal 127,IntegerVal (-128),IntegerVal (-66),IntegerVal 0],VectorVal [IntegerVal 0,IntegerVal 72,IntegerVal (-120),IntegerVal 0,IntegerVal (-128),IntegerVal (-1),IntegerVal (-1),IntegerVal (-128),IntegerVal 127,IntegerVal 48,IntegerVal 0,IntegerVal (-128),IntegerVal (-128),IntegerVal (-128),IntegerVal 0,IntegerVal (-128)]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s8(vcreate_s8(UINT64_C(0x7fff004bff7f7f00)),
                         vcreate_s8(UINT64_C(0x00be807f7fff00ff)));
      arg2 = vcombine_s8(vcreate_s8(UINT64_C(0x80ffff8000884800)),
                         vcreate_s8(UINT64_C(0x800080808000307f)));
      clear_neon_saturated();
      //  Expect: "result" = 0000807f7f00307f7fff004b007f7f00
      result = vmaxq_s8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result), 0);
         exp = UINT64_C(0x7fff004b007f7f00);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result), 1);
         exp = UINT64_C(0x0000807f7f00307f);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_701() {

{
   {
      int16x8_t arg1;
      int16x8_t arg2;
      int16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"max\", fnname = \"vmaxq_s16\", rettype = \"int16x8_t\", argtypes = \"[int16x8_t,int16x8_t]\", vals = [VectorVal [IntegerVal (-32768),IntegerVal (-11505),IntegerVal (-30963),IntegerVal (-1),IntegerVal 0,IntegerVal (-1),IntegerVal 32767,IntegerVal (-32768)],VectorVal [IntegerVal (-1),IntegerVal 0,IntegerVal 0,IntegerVal 0,IntegerVal (-29310),IntegerVal 0,IntegerVal (-32768),IntegerVal (-32768)]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s16(vcreate_s16(UINT64_C(0xffff870dd30f8000)),
                          vcreate_s16(UINT64_C(0x80007fffffff0000)));
      arg2 = vcombine_s16(vcreate_s16(UINT64_C(0x000000000000ffff)),
                          vcreate_s16(UINT64_C(0x8000800000008d82)));
      clear_neon_saturated();
      //  Expect: "result" = 80007fff00000000000000000000ffff
      result = vmaxq_s16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 0);
         exp = UINT64_C(0x000000000000ffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 1);
         exp = UINT64_C(0x80007fff00000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_702() {

{
   {
      int32x4_t arg1;
      int32x4_t arg2;
      int32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"max\", fnname = \"vmaxq_s32\", rettype = \"int32x4_t\", argtypes = \"[int32x4_t,int32x4_t]\", vals = [VectorVal [IntegerVal 2147418112,IntegerVal 2147418112,IntegerVal (-1),IntegerVal 65535],VectorVal [IntegerVal (-2147483648),IntegerVal 178094596,IntegerVal 2147418112,IntegerVal 51514]], start_saturated = True}";
      int reported = 0;
      arg1 = vcombine_s32(vcreate_s32(UINT64_C(0x7fff00007fff0000)),
                          vcreate_s32(UINT64_C(0x0000ffffffffffff)));
      arg2 = vcombine_s32(vcreate_s32(UINT64_C(0x0a9d820480000000)),
                          vcreate_s32(UINT64_C(0x0000c93a7fff0000)));
      set_neon_saturated();
      //  Expect: "result" = 0000ffff7fff00007fff00007fff0000
      result = vmaxq_s32(arg1, arg2);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 0);
         exp = UINT64_C(0x7fff00007fff0000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 1);
         exp = UINT64_C(0x0000ffff7fff0000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_703() {

{
   {
      uint8x16_t arg1;
      uint8x16_t arg2;
      uint8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"max\", fnname = \"vmaxq_u8\", rettype = \"uint8x16_t\", argtypes = \"[uint8x16_t,uint8x16_t]\", vals = [VectorVal [IntegerVal 127,IntegerVal 3,IntegerVal 54,IntegerVal 255,IntegerVal 255,IntegerVal 255,IntegerVal 81,IntegerVal 141,IntegerVal 0,IntegerVal 221,IntegerVal 255,IntegerVal 153,IntegerVal 0,IntegerVal 128,IntegerVal 41,IntegerVal 128],VectorVal [IntegerVal 127,IntegerVal 128,IntegerVal 0,IntegerVal 127,IntegerVal 0,IntegerVal 0,IntegerVal 127,IntegerVal 128,IntegerVal 255,IntegerVal 155,IntegerVal 0,IntegerVal 255,IntegerVal 86,IntegerVal 127,IntegerVal 0,IntegerVal 127]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u8(vcreate_u8(UINT64_C(0x8d51ffffff36037f)),
                         vcreate_u8(UINT64_C(0x8029800099ffdd00)));
      arg2 = vcombine_u8(vcreate_u8(UINT64_C(0x807f00007f00807f)),
                         vcreate_u8(UINT64_C(0x7f007f56ff009bff)));
      clear_neon_saturated();
      //  Expect: "result" = 80298056ffffddff8d7fffffff36807f
      result = vmaxq_u8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 0);
         exp = UINT64_C(0x8d7fffffff36807f);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 1);
         exp = UINT64_C(0x80298056ffffddff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_704() {

{
   {
      uint16x8_t arg1;
      uint16x8_t arg2;
      uint16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"max\", fnname = \"vmaxq_u16\", rettype = \"uint16x8_t\", argtypes = \"[uint16x8_t,uint16x8_t]\", vals = [VectorVal [IntegerVal 32768,IntegerVal 65535,IntegerVal 32768,IntegerVal 17513,IntegerVal 43137,IntegerVal 65535,IntegerVal 0,IntegerVal 28844],VectorVal [IntegerVal 40727,IntegerVal 31948,IntegerVal 32767,IntegerVal 32767,IntegerVal 32768,IntegerVal 32767,IntegerVal 0,IntegerVal 32767]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u16(vcreate_u16(UINT64_C(0x44698000ffff8000)),
                          vcreate_u16(UINT64_C(0x70ac0000ffffa881)));
      arg2 = vcombine_u16(vcreate_u16(UINT64_C(0x7fff7fff7ccc9f17)),
                          vcreate_u16(UINT64_C(0x7fff00007fff8000)));
      clear_neon_saturated();
      //  Expect: "result" = 7fff0000ffffa8817fff8000ffff9f17
      result = vmaxq_u16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 0);
         exp = UINT64_C(0x7fff8000ffff9f17);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 1);
         exp = UINT64_C(0x7fff0000ffffa881);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_705() {

{
   {
      uint32x4_t arg1;
      uint32x4_t arg2;
      uint32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"max\", fnname = \"vmaxq_u32\", rettype = \"uint32x4_t\", argtypes = \"[uint32x4_t,uint32x4_t]\", vals = [VectorVal [IntegerVal 4294934528,IntegerVal 4294934528,IntegerVal 2147418112,IntegerVal 44096],VectorVal [IntegerVal 2147418112,IntegerVal 2147483348,IntegerVal 32767,IntegerVal 289079295]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u32(vcreate_u32(UINT64_C(0xffff8000ffff8000)),
                          vcreate_u32(UINT64_C(0x0000ac407fff0000)));
      arg2 = vcombine_u32(vcreate_u32(UINT64_C(0x7ffffed47fff0000)),
                          vcreate_u32(UINT64_C(0x113affff00007fff)));
      clear_neon_saturated();
      //  Expect: "result" = 113affff7fff0000ffff8000ffff8000
      result = vmaxq_u32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 0);
         exp = UINT64_C(0xffff8000ffff8000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 1);
         exp = UINT64_C(0x113affff7fff0000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_706() {

{
   {
      float32x4_t arg1;
      float32x4_t arg2;
      float32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"max\", fnname = \"vmaxq_f32\", rettype = \"float32x4_t\", argtypes = \"[float32x4_t,float32x4_t]\", vals = [VectorVal [FloatVal 0.8653736114501953,FloatVal 0.8545435667037964,FloatVal 0.10120481252670288,FloatVal 0.5059875845909119],VectorVal [FloatVal 0.9511799216270447,FloatVal 0.9979314208030701,FloatVal 0.5168318152427673,FloatVal 0.6158478856086731]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_f32(vcreate_f32(UINT64_C(0x3f5ac35e3f5d8920)),
                          vcreate_f32(UINT64_C(0x3f0188673dcf4478)));
      arg2 = vcombine_f32(vcreate_f32(UINT64_C(0x3f7f786f3f738087)),
                          vcreate_f32(UINT64_C(0x3f1da8353f044f17)));
      clear_neon_saturated();
      //  Expect: "result" = 3f1da8353f044f173f7f786f3f738087
      result = vmaxq_f32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 0);
         exp = ((float32_t) 0.9511799216270447);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 1);
         exp = ((float32_t) 0.9979314208030701);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 2);
         exp = ((float32_t) 0.5168318152427673);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 2 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 3);
         exp = ((float32_t) 0.6158478856086731);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 3 ", exp, got);
            }
      }
   }
}
}
void dotests_707() {

{
   {
      float64x1_t arg1;
      float64x1_t arg2;
      float64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"max\", fnname = \"vmax_f64\", rettype = \"float64x1_t\", argtypes = \"[float64x1_t,float64x1_t]\", vals = [VectorVal [FloatVal 0.1529529429955867],VectorVal [FloatVal 0.20186470609205365]], start_saturated = False}";
      int reported = 0;
      float64_t got;
      float64_t exp;
      arg1 = vcreate_f64(UINT64_C(0x3fc393f647ff1a88));
      arg2 = vcreate_f64(UINT64_C(0x3fc9d6b3e370e61c));
      clear_neon_saturated();
      //  Expect: "result" = 3fc9d6b3e370e61c
      result = vmax_f64(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_f64(result, 0);
      exp = 0.20186470609205365;
      if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
         }
   }
}
}
void dotests_708() {

{
   {
      float64x2_t arg1;
      float64x2_t arg2;
      float64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"max\", fnname = \"vmaxq_f64\", rettype = \"float64x2_t\", argtypes = \"[float64x2_t,float64x2_t]\", vals = [VectorVal [FloatVal 0.3252851977861767,FloatVal 0.14322176723946944],VectorVal [FloatVal 0.44325342610978546,FloatVal 4.619336634112714e-2]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_f64(vcreate_f64(UINT64_C(0x3fd4d1790197544e)),
                          vcreate_f64(UINT64_C(0x3fc25517432f3654)));
      arg2 = vcombine_f64(vcreate_f64(UINT64_C(0x3fdc5e439e3ed096)),
                          vcreate_f64(UINT64_C(0x3fa7a6a82b745f20)));
      clear_neon_saturated();
      //  Expect: "result" = 3fc25517432f36543fdc5e439e3ed096
      result = vmaxq_f64(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float64_t got;
         float64_t exp;
         got = vgetq_lane_f64(result, 0);
         exp = 0.44325342610978546;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float64_t got;
         float64_t exp;
         got = vgetq_lane_f64(result, 1);
         exp = 0.14322176723946944;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
   }
}
}
void dotests_709() {

{
   {
      float32x2_t arg1;
      float32x2_t arg2;
      float32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"maxnm\", fnname = \"vmaxnm_f32\", rettype = \"float32x2_t\", argtypes = \"[float32x2_t,float32x2_t]\", vals = [VectorVal [FloatVal 0.48767781257629395,FloatVal 9.1411292552948e-2],VectorVal [FloatVal 8.409726619720459e-2,FloatVal 3.877747058868408e-2]], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_f32(UINT64_C(0x3dbb35d83ef9b0e8));
      arg2 = vcreate_f32(UINT64_C(0x3d1ed5203dac3b30));
      clear_neon_saturated();
      //  Expect: "result" = 3dbb35d83ef9b0e8
      result = vmaxnm_f32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result, 0);
         exp = ((float32_t) 0.48767781257629395);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result, 1);
         exp = ((float32_t) 9.1411292552948e-2);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
   }
}
}
void dotests_710() {

{
   {
      float64x1_t arg1;
      float64x1_t arg2;
      float64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"maxnm\", fnname = \"vmaxnm_f64\", rettype = \"float64x1_t\", argtypes = \"[float64x1_t,float64x1_t]\", vals = [VectorVal [FloatVal 0.3628751781246776],VectorVal [FloatVal 0.6386486926766302]], start_saturated = False}";
      int reported = 0;
      float64_t got;
      float64_t exp;
      arg1 = vcreate_f64(UINT64_C(0x3fd73958cfa4d7b2));
      arg2 = vcreate_f64(UINT64_C(0x3fe46fcf6215bcac));
      clear_neon_saturated();
      //  Expect: "result" = 3fe46fcf6215bcac
      result = vmaxnm_f64(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_f64(result, 0);
      exp = 0.6386486926766302;
      if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
         }
   }
}
}
void dotests_711() {

{
   {
      float32x4_t arg1;
      float32x4_t arg2;
      float32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"maxnm\", fnname = \"vmaxnmq_f32\", rettype = \"float32x4_t\", argtypes = \"[float32x4_t,float32x4_t]\", vals = [VectorVal [FloatVal 0.9336029291152954,FloatVal 2.276700735092163e-2,FloatVal 0.37401074171066284,FloatVal 0.8883823156356812],VectorVal [FloatVal 0.3901272416114807,FloatVal 0.7585092186927795,FloatVal 0.8847666382789612,FloatVal 0.8996394872665405]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_f32(vcreate_f32(UINT64_C(0x3cba81e03f6f009a)),
                          vcreate_f32(UINT64_C(0x3f636d063ebf7e56)));
      arg2 = vcombine_f32(vcreate_f32(UINT64_C(0x3f422da93ec7bec2)),
                          vcreate_f32(UINT64_C(0x3f664ec63f628011)));
      clear_neon_saturated();
      //  Expect: "result" = 3f664ec63f6280113f422da93f6f009a
      result = vmaxnmq_f32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 0);
         exp = ((float32_t) 0.9336029291152954);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 1);
         exp = ((float32_t) 0.7585092186927795);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 2);
         exp = ((float32_t) 0.8847666382789612);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 2 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 3);
         exp = ((float32_t) 0.8996394872665405);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 3 ", exp, got);
            }
      }
   }
}
}
void dotests_712() {

{
   {
      float64x2_t arg1;
      float64x2_t arg2;
      float64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"maxnm\", fnname = \"vmaxnmq_f64\", rettype = \"float64x2_t\", argtypes = \"[float64x2_t,float64x2_t]\", vals = [VectorVal [FloatVal 0.8780223729106382,FloatVal 0.2912466735119569],VectorVal [FloatVal 0.45333322741176385,FloatVal 0.1158142387234452]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_f64(vcreate_f64(UINT64_C(0x3fec18c26019d71a)),
                          vcreate_f64(UINT64_C(0x3fd2a3c916735e86)));
      arg2 = vcombine_f64(vcreate_f64(UINT64_C(0x3fdd03695e7b1d30)),
                          vcreate_f64(UINT64_C(0x3fbda6007fba7418)));
      clear_neon_saturated();
      //  Expect: "result" = 3fd2a3c916735e863fec18c26019d71a
      result = vmaxnmq_f64(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float64_t got;
         float64_t exp;
         got = vgetq_lane_f64(result, 0);
         exp = 0.8780223729106382;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float64_t got;
         float64_t exp;
         got = vgetq_lane_f64(result, 1);
         exp = 0.2912466735119569;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
   }
}
}
void dotests_713() {

{
   {
      int8x8_t arg1;
      int8x8_t arg2;
      int8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"min\", fnname = \"vmin_s8\", rettype = \"int8x8_t\", argtypes = \"[int8x8_t,int8x8_t]\", vals = [VectorVal [IntegerVal (-1),IntegerVal 127,IntegerVal (-128),IntegerVal 0,IntegerVal 0,IntegerVal 127,IntegerVal (-88),IntegerVal (-1)],VectorVal [IntegerVal (-128),IntegerVal 127,IntegerVal (-1),IntegerVal (-128),IntegerVal 127,IntegerVal 0,IntegerVal (-43),IntegerVal 114]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s8(UINT64_C(0xffa87f0000807fff));
      arg2 = vcreate_s8(UINT64_C(0x72d5007f80ff7f80));
      clear_neon_saturated();
      //  Expect: "result" = ffa8000080807f80
      result = vmin_s8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s8(result), 0);
      exp = UINT64_C(0xffa8000080807f80);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_714() {

{
   {
      int16x4_t arg1;
      int16x4_t arg2;
      int16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"min\", fnname = \"vmin_s16\", rettype = \"int16x4_t\", argtypes = \"[int16x4_t,int16x4_t]\", vals = [VectorVal [IntegerVal (-24684),IntegerVal 32767,IntegerVal (-1),IntegerVal 32767],VectorVal [IntegerVal 0,IntegerVal 17616,IntegerVal (-1),IntegerVal (-1)]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s16(UINT64_C(0x7fffffff7fff9f94));
      arg2 = vcreate_s16(UINT64_C(0xffffffff44d00000));
      clear_neon_saturated();
      //  Expect: "result" = ffffffff44d09f94
      result = vmin_s16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s16(result), 0);
      exp = UINT64_C(0xffffffff44d09f94);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_715() {

{
   {
      int32x2_t arg1;
      int32x2_t arg2;
      int32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"min\", fnname = \"vmin_s32\", rettype = \"int32x2_t\", argtypes = \"[int32x2_t,int32x2_t]\", vals = [VectorVal [IntegerVal 251516989,IntegerVal (-2147443442)],VectorVal [IntegerVal (-1432190976),IntegerVal 1829076992]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s32(UINT64_C(0x80009d0e0efdd83d));
      arg2 = vcreate_s32(UINT64_C(0x6d058000aaa28000));
      clear_neon_saturated();
      //  Expect: "result" = 80009d0eaaa28000
      result = vmin_s32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s32(result), 0);
      exp = UINT64_C(0x80009d0eaaa28000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_716() {

{
   {
      uint8x8_t arg1;
      uint8x8_t arg2;
      uint8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"min\", fnname = \"vmin_u8\", rettype = \"uint8x8_t\", argtypes = \"[uint8x8_t,uint8x8_t]\", vals = [VectorVal [IntegerVal 39,IntegerVal 127,IntegerVal 255,IntegerVal 176,IntegerVal 36,IntegerVal 183,IntegerVal 9,IntegerVal 255],VectorVal [IntegerVal 128,IntegerVal 100,IntegerVal 255,IntegerVal 115,IntegerVal 127,IntegerVal 128,IntegerVal 255,IntegerVal 0]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u8(UINT64_C(0xff09b724b0ff7f27));
      arg2 = vcreate_u8(UINT64_C(0x00ff807f73ff6480));
      clear_neon_saturated();
      //  Expect: "result" = 0009802473ff6427
      result = vmin_u8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u8(result), 0);
      exp = UINT64_C(0x0009802473ff6427);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_717() {

{
   {
      uint16x4_t arg1;
      uint16x4_t arg2;
      uint16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"min\", fnname = \"vmin_u16\", rettype = \"uint16x4_t\", argtypes = \"[uint16x4_t,uint16x4_t]\", vals = [VectorVal [IntegerVal 65535,IntegerVal 0,IntegerVal 0,IntegerVal 0],VectorVal [IntegerVal 32767,IntegerVal 65535,IntegerVal 36920,IntegerVal 0]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u16(UINT64_C(0x000000000000ffff));
      arg2 = vcreate_u16(UINT64_C(0x00009038ffff7fff));
      clear_neon_saturated();
      //  Expect: "result" = 0000000000007fff
      result = vmin_u16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u16(result), 0);
      exp = UINT64_C(0x0000000000007fff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_718() {

{
   {
      uint32x2_t arg1;
      uint32x2_t arg2;
      uint32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"min\", fnname = \"vmin_u32\", rettype = \"uint32x2_t\", argtypes = \"[uint32x2_t,uint32x2_t]\", vals = [VectorVal [IntegerVal 55126,IntegerVal 2147516415],VectorVal [IntegerVal 2147516416,IntegerVal 32768]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u32(UINT64_C(0x80007fff0000d756));
      arg2 = vcreate_u32(UINT64_C(0x0000800080008000));
      clear_neon_saturated();
      //  Expect: "result" = 000080000000d756
      result = vmin_u32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u32(result), 0);
      exp = UINT64_C(0x000080000000d756);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_719() {

{
   {
      float32x2_t arg1;
      float32x2_t arg2;
      float32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"min\", fnname = \"vmin_f32\", rettype = \"float32x2_t\", argtypes = \"[float32x2_t,float32x2_t]\", vals = [VectorVal [FloatVal 0.21347248554229736,FloatVal 0.6310522556304932],VectorVal [FloatVal 0.21288388967514038,FloatVal 0.16579222679138184]], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_f32(UINT64_C(0x3f218ca43e5a9888));
      arg2 = vcreate_f32(UINT64_C(0x3e29c5703e59fe3c));
      clear_neon_saturated();
      //  Expect: "result" = 3e29c5703e59fe3c
      result = vmin_f32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result, 0);
         exp = ((float32_t) 0.21288388967514038);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result, 1);
         exp = ((float32_t) 0.16579222679138184);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
   }
}
}
void dotests_720() {

{
   {
      int8x16_t arg1;
      int8x16_t arg2;
      int8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"min\", fnname = \"vminq_s8\", rettype = \"int8x16_t\", argtypes = \"[int8x16_t,int8x16_t]\", vals = [VectorVal [IntegerVal 127,IntegerVal (-1),IntegerVal (-128),IntegerVal (-1),IntegerVal (-1),IntegerVal (-128),IntegerVal (-1),IntegerVal (-1),IntegerVal 127,IntegerVal (-1),IntegerVal (-1),IntegerVal (-1),IntegerVal 127,IntegerVal (-53),IntegerVal (-1),IntegerVal 0],VectorVal [IntegerVal 127,IntegerVal (-73),IntegerVal 127,IntegerVal 0,IntegerVal 0,IntegerVal (-1),IntegerVal (-1),IntegerVal 127,IntegerVal (-1),IntegerVal (-128),IntegerVal (-128),IntegerVal 127,IntegerVal (-128),IntegerVal 0,IntegerVal (-128),IntegerVal (-128)]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s8(vcreate_s8(UINT64_C(0xffff80ffff80ff7f)),
                         vcreate_s8(UINT64_C(0x00ffcb7fffffff7f)));
      arg2 = vcombine_s8(vcreate_s8(UINT64_C(0x7fffff00007fb77f)),
                         vcreate_s8(UINT64_C(0x808000807f8080ff)));
      clear_neon_saturated();
      //  Expect: "result" = 8080cb80ff8080ffffff80ffff80b77f
      result = vminq_s8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result), 0);
         exp = UINT64_C(0xffff80ffff80b77f);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result), 1);
         exp = UINT64_C(0x8080cb80ff8080ff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_721() {

{
   {
      int16x8_t arg1;
      int16x8_t arg2;
      int16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"min\", fnname = \"vminq_s16\", rettype = \"int16x8_t\", argtypes = \"[int16x8_t,int16x8_t]\", vals = [VectorVal [IntegerVal (-3764),IntegerVal 0,IntegerVal 32767,IntegerVal (-1),IntegerVal 0,IntegerVal 10745,IntegerVal (-32768),IntegerVal 0],VectorVal [IntegerVal (-32768),IntegerVal (-32768),IntegerVal 15100,IntegerVal (-1),IntegerVal (-32768),IntegerVal (-1),IntegerVal 32767,IntegerVal (-32768)]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s16(vcreate_s16(UINT64_C(0xffff7fff0000f14c)),
                          vcreate_s16(UINT64_C(0x0000800029f90000)));
      arg2 = vcombine_s16(vcreate_s16(UINT64_C(0xffff3afc80008000)),
                          vcreate_s16(UINT64_C(0x80007fffffff8000)));
      clear_neon_saturated();
      //  Expect: "result" = 80008000ffff8000ffff3afc80008000
      result = vminq_s16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 0);
         exp = UINT64_C(0xffff3afc80008000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 1);
         exp = UINT64_C(0x80008000ffff8000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_722() {

{
   {
      int32x4_t arg1;
      int32x4_t arg2;
      int32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"min\", fnname = \"vminq_s32\", rettype = \"int32x4_t\", argtypes = \"[int32x4_t,int32x4_t]\", vals = [VectorVal [IntegerVal 1116831744,IntegerVal (-2147450880),IntegerVal 2147471656,IntegerVal 65535],VectorVal [IntegerVal 2147457647,IntegerVal (-2147450881),IntegerVal 32767,IntegerVal 1942593403]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s32(vcreate_s32(UINT64_C(0x8000800042918000)),
                          vcreate_s32(UINT64_C(0x0000ffff7fffd128)));
      arg2 = vcombine_s32(vcreate_s32(UINT64_C(0x80007fff7fff9a6f)),
                          vcreate_s32(UINT64_C(0x73c99f7b00007fff)));
      clear_neon_saturated();
      //  Expect: "result" = 0000ffff00007fff80007fff42918000
      result = vminq_s32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 0);
         exp = UINT64_C(0x80007fff42918000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 1);
         exp = UINT64_C(0x0000ffff00007fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_723() {

{
   {
      uint8x16_t arg1;
      uint8x16_t arg2;
      uint8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"min\", fnname = \"vminq_u8\", rettype = \"uint8x16_t\", argtypes = \"[uint8x16_t,uint8x16_t]\", vals = [VectorVal [IntegerVal 128,IntegerVal 0,IntegerVal 0,IntegerVal 127,IntegerVal 252,IntegerVal 255,IntegerVal 13,IntegerVal 127,IntegerVal 0,IntegerVal 55,IntegerVal 255,IntegerVal 127,IntegerVal 128,IntegerVal 52,IntegerVal 0,IntegerVal 0],VectorVal [IntegerVal 128,IntegerVal 127,IntegerVal 128,IntegerVal 0,IntegerVal 0,IntegerVal 0,IntegerVal 255,IntegerVal 0,IntegerVal 127,IntegerVal 127,IntegerVal 127,IntegerVal 127,IntegerVal 255,IntegerVal 128,IntegerVal 221,IntegerVal 255]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u8(vcreate_u8(UINT64_C(0x7f0dfffc7f000080)),
                         vcreate_u8(UINT64_C(0x000034807fff3700)));
      arg2 = vcombine_u8(vcreate_u8(UINT64_C(0x00ff000000807f80)),
                         vcreate_u8(UINT64_C(0xffdd80ff7f7f7f7f)));
      clear_neon_saturated();
      //  Expect: "result" = 000034807f7f3700000d000000000080
      result = vminq_u8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 0);
         exp = UINT64_C(0x000d000000000080);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 1);
         exp = UINT64_C(0x000034807f7f3700);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_724() {

{
   {
      uint16x8_t arg1;
      uint16x8_t arg2;
      uint16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"min\", fnname = \"vminq_u16\", rettype = \"uint16x8_t\", argtypes = \"[uint16x8_t,uint16x8_t]\", vals = [VectorVal [IntegerVal 43724,IntegerVal 32767,IntegerVal 32768,IntegerVal 32768,IntegerVal 65535,IntegerVal 0,IntegerVal 34158,IntegerVal 65535],VectorVal [IntegerVal 65535,IntegerVal 65535,IntegerVal 0,IntegerVal 32768,IntegerVal 65535,IntegerVal 32767,IntegerVal 32767,IntegerVal 65535]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u16(vcreate_u16(UINT64_C(0x800080007fffaacc)),
                          vcreate_u16(UINT64_C(0xffff856e0000ffff)));
      arg2 = vcombine_u16(vcreate_u16(UINT64_C(0x80000000ffffffff)),
                          vcreate_u16(UINT64_C(0xffff7fff7fffffff)));
      clear_neon_saturated();
      //  Expect: "result" = ffff7fff0000ffff800000007fffaacc
      result = vminq_u16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 0);
         exp = UINT64_C(0x800000007fffaacc);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 1);
         exp = UINT64_C(0xffff7fff0000ffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_725() {

{
   {
      uint32x4_t arg1;
      uint32x4_t arg2;
      uint32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"min\", fnname = \"vminq_u32\", rettype = \"uint32x4_t\", argtypes = \"[uint32x4_t,uint32x4_t]\", vals = [VectorVal [IntegerVal 4294967295,IntegerVal 1949564927,IntegerVal 1335427072,IntegerVal 2147520507],VectorVal [IntegerVal 2147483647,IntegerVal 2147418112,IntegerVal 2147418112,IntegerVal 32768]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u32(vcreate_u32(UINT64_C(0x7433ffffffffffff)),
                          vcreate_u32(UINT64_C(0x80008ffb4f990000)));
      arg2 = vcombine_u32(vcreate_u32(UINT64_C(0x7fff00007fffffff)),
                          vcreate_u32(UINT64_C(0x000080007fff0000)));
      clear_neon_saturated();
      //  Expect: "result" = 000080004f9900007433ffff7fffffff
      result = vminq_u32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 0);
         exp = UINT64_C(0x7433ffff7fffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 1);
         exp = UINT64_C(0x000080004f990000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_726() {

{
   {
      float32x4_t arg1;
      float32x4_t arg2;
      float32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"min\", fnname = \"vminq_f32\", rettype = \"float32x4_t\", argtypes = \"[float32x4_t,float32x4_t]\", vals = [VectorVal [FloatVal 0.5185741186141968,FloatVal 0.33730602264404297,FloatVal 7.397931814193726e-2,FloatVal 0.2353324294090271],VectorVal [FloatVal 0.905457079410553,FloatVal 0.3810897469520569,FloatVal 0.5982356667518616,FloatVal 0.396991491317749]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_f32(vcreate_f32(UINT64_C(0x3eacb3603f04c146)),
                          vcreate_f32(UINT64_C(0x3e70fafc3d978278)));
      arg2 = vcombine_f32(vcreate_f32(UINT64_C(0x3ec31e323f67cc09)),
                          vcreate_f32(UINT64_C(0x3ecb42783f1925f9)));
      clear_neon_saturated();
      //  Expect: "result" = 3e70fafc3d9782783eacb3603f04c146
      result = vminq_f32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 0);
         exp = ((float32_t) 0.5185741186141968);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 1);
         exp = ((float32_t) 0.33730602264404297);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 2);
         exp = ((float32_t) 7.397931814193726e-2);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 2 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 3);
         exp = ((float32_t) 0.2353324294090271);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 3 ", exp, got);
            }
      }
   }
}
}
void dotests_727() {

{
   {
      float64x1_t arg1;
      float64x1_t arg2;
      float64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"min\", fnname = \"vmin_f64\", rettype = \"float64x1_t\", argtypes = \"[float64x1_t,float64x1_t]\", vals = [VectorVal [FloatVal 2.455644142584479e-2],VectorVal [FloatVal 0.37047439983443475]], start_saturated = False}";
      int reported = 0;
      float64_t got;
      float64_t exp;
      arg1 = vcreate_f64(UINT64_C(0x3f992552e3521100));
      arg2 = vcreate_f64(UINT64_C(0x3fd7b5da41d2d2f2));
      clear_neon_saturated();
      //  Expect: "result" = 3f992552e3521100
      result = vmin_f64(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_f64(result, 0);
      exp = 2.455644142584479e-2;
      if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
         }
   }
}
}
void dotests_728() {

{
   {
      float64x2_t arg1;
      float64x2_t arg2;
      float64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"min\", fnname = \"vminq_f64\", rettype = \"float64x2_t\", argtypes = \"[float64x2_t,float64x2_t]\", vals = [VectorVal [FloatVal 0.422031620859342,FloatVal 0.262736766671836],VectorVal [FloatVal 0.3724705598940943,FloatVal 0.799729767036177]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_f64(vcreate_f64(UINT64_C(0x3fdb0290ea5dffec)),
                          vcreate_f64(UINT64_C(0x3fd0d0addf13fd06)));
      arg2 = vcombine_f64(vcreate_f64(UINT64_C(0x3fd7d68ec25df2cc)),
                          vcreate_f64(UINT64_C(0x3fe99762e161dbc9)));
      clear_neon_saturated();
      //  Expect: "result" = 3fd0d0addf13fd063fd7d68ec25df2cc
      result = vminq_f64(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float64_t got;
         float64_t exp;
         got = vgetq_lane_f64(result, 0);
         exp = 0.3724705598940943;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float64_t got;
         float64_t exp;
         got = vgetq_lane_f64(result, 1);
         exp = 0.262736766671836;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
   }
}
}
void dotests_729() {

{
   {
      float32x2_t arg1;
      float32x2_t arg2;
      float32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"minnm\", fnname = \"vminnm_f32\", rettype = \"float32x2_t\", argtypes = \"[float32x2_t,float32x2_t]\", vals = [VectorVal [FloatVal 0.24446570873260498,FloatVal 0.19556599855422974],VectorVal [FloatVal 0.35794925689697266,FloatVal 0.5256140828132629]], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_f32(UINT64_C(0x3e4842743e7a5538));
      arg2 = vcreate_f32(UINT64_C(0x3f068ea53eb74520));
      clear_neon_saturated();
      //  Expect: "result" = 3e4842743e7a5538
      result = vminnm_f32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result, 0);
         exp = ((float32_t) 0.24446570873260498);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result, 1);
         exp = ((float32_t) 0.19556599855422974);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
   }
}
}
void dotests_730() {

{
   {
      float64x1_t arg1;
      float64x1_t arg2;
      float64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"minnm\", fnname = \"vminnm_f64\", rettype = \"float64x1_t\", argtypes = \"[float64x1_t,float64x1_t]\", vals = [VectorVal [FloatVal 0.2852436966479541],VectorVal [FloatVal 0.1726533279362853]], start_saturated = False}";
      int reported = 0;
      float64_t got;
      float64_t exp;
      arg1 = vcreate_f64(UINT64_C(0x3fd2416ec71f8f14));
      arg2 = vcreate_f64(UINT64_C(0x3fc6198116841594));
      clear_neon_saturated();
      //  Expect: "result" = 3fc6198116841594
      result = vminnm_f64(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_f64(result, 0);
      exp = 0.1726533279362853;
      if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
         }
   }
}
}
void dotests_731() {

{
   {
      float32x4_t arg1;
      float32x4_t arg2;
      float32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"minnm\", fnname = \"vminnmq_f32\", rettype = \"float32x4_t\", argtypes = \"[float32x4_t,float32x4_t]\", vals = [VectorVal [FloatVal 0.7236864566802979,FloatVal 0.5972795486450195,FloatVal 0.3949301838874817,FloatVal 0.7579085230827332],VectorVal [FloatVal 0.21137607097625732,FloatVal 0.6767245531082153,FloatVal 0.8596462607383728,FloatVal 0.9067000150680542]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_f32(vcreate_f32(UINT64_C(0x3f18e7503f394384)),
                          vcreate_f32(UINT64_C(0x3f42064b3eca344a)));
      arg2 = vcombine_f32(vcreate_f32(UINT64_C(0x3f2d3dd23e5872f8)),
                          vcreate_f32(UINT64_C(0x3f681d7e3f5c11c7)));
      clear_neon_saturated();
      //  Expect: "result" = 3f42064b3eca344a3f18e7503e5872f8
      result = vminnmq_f32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 0);
         exp = ((float32_t) 0.21137607097625732);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 1);
         exp = ((float32_t) 0.5972795486450195);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 2);
         exp = ((float32_t) 0.3949301838874817);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 2 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 3);
         exp = ((float32_t) 0.7579085230827332);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 3 ", exp, got);
            }
      }
   }
}
}
void dotests_732() {

{
   {
      float64x2_t arg1;
      float64x2_t arg2;
      float64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"minnm\", fnname = \"vminnmq_f64\", rettype = \"float64x2_t\", argtypes = \"[float64x2_t,float64x2_t]\", vals = [VectorVal [FloatVal 0.441561555108134,FloatVal 0.9044037354613381],VectorVal [FloatVal 0.3879150663029872,FloatVal 0.12073705468380425]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_f64(vcreate_f64(UINT64_C(0x3fdc428b65970fc4)),
                          vcreate_f64(UINT64_C(0x3fecf0e01a45f94e)));
      arg2 = vcombine_f64(vcreate_f64(UINT64_C(0x3fd8d399b6d9687a)),
                          vcreate_f64(UINT64_C(0x3fbee89fa5484500)));
      clear_neon_saturated();
      //  Expect: "result" = 3fbee89fa54845003fd8d399b6d9687a
      result = vminnmq_f64(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float64_t got;
         float64_t exp;
         got = vgetq_lane_f64(result, 0);
         exp = 0.3879150663029872;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float64_t got;
         float64_t exp;
         got = vgetq_lane_f64(result, 1);
         exp = 0.12073705468380425;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
   }
}
}
void dotests_733() {

{
   {
      int8x8_t arg1;
      int8x8_t arg2;
      int8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"sum\", fnname = \"vpadd_s8\", rettype = \"int8x8_t\", argtypes = \"[int8x8_t,int8x8_t]\", vals = [VectorVal [IntegerVal 127,IntegerVal (-1),IntegerVal 127,IntegerVal (-1),IntegerVal 127,IntegerVal (-1),IntegerVal 0,IntegerVal (-128)],VectorVal [IntegerVal (-128),IntegerVal (-128),IntegerVal 0,IntegerVal (-32),IntegerVal 0,IntegerVal 127,IntegerVal 127,IntegerVal (-128)]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s8(UINT64_C(0x8000ff7fff7fff7f));
      arg2 = vcreate_s8(UINT64_C(0x807f7f00e0008080));
      clear_neon_saturated();
      //  Expect: "result" = ff7fe000807e7e7e
      result = vpadd_s8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s8(result), 0);
      exp = UINT64_C(0xff7fe000807e7e7e);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_734() {

{
   {
      int16x4_t arg1;
      int16x4_t arg2;
      int16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"sum\", fnname = \"vpadd_s16\", rettype = \"int16x4_t\", argtypes = \"[int16x4_t,int16x4_t]\", vals = [VectorVal [IntegerVal (-1),IntegerVal 0,IntegerVal 0,IntegerVal 0],VectorVal [IntegerVal (-32768),IntegerVal (-32768),IntegerVal 0,IntegerVal (-11697)]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s16(UINT64_C(0x000000000000ffff));
      arg2 = vcreate_s16(UINT64_C(0xd24f000080008000));
      clear_neon_saturated();
      //  Expect: "result" = d24f00000000ffff
      result = vpadd_s16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s16(result), 0);
      exp = UINT64_C(0xd24f00000000ffff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_735() {

{
   {
      int32x2_t arg1;
      int32x2_t arg2;
      int32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"sum\", fnname = \"vpadd_s32\", rettype = \"int32x2_t\", argtypes = \"[int32x2_t,int32x2_t]\", vals = [VectorVal [IntegerVal (-2147483648),IntegerVal 2147468527],VectorVal [IntegerVal (-2147450880),IntegerVal (-32769)]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s32(UINT64_C(0x7fffc4ef80000000));
      arg2 = vcreate_s32(UINT64_C(0xffff7fff80008000));
      clear_neon_saturated();
      //  Expect: "result" = 7fffffffffffc4ef
      result = vpadd_s32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s32(result), 0);
      exp = UINT64_C(0x7fffffffffffc4ef);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_736() {

{
   {
      uint8x8_t arg1;
      uint8x8_t arg2;
      uint8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"sum\", fnname = \"vpadd_u8\", rettype = \"uint8x8_t\", argtypes = \"[uint8x8_t,uint8x8_t]\", vals = [VectorVal [IntegerVal 128,IntegerVal 255,IntegerVal 127,IntegerVal 128,IntegerVal 0,IntegerVal 255,IntegerVal 127,IntegerVal 127],VectorVal [IntegerVal 127,IntegerVal 191,IntegerVal 127,IntegerVal 255,IntegerVal 0,IntegerVal 67,IntegerVal 255,IntegerVal 127]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u8(UINT64_C(0x7f7fff00807fff80));
      arg2 = vcreate_u8(UINT64_C(0x7fff4300ff7fbf7f));
      clear_neon_saturated();
      //  Expect: "result" = 7e437e3efeffff7f
      result = vpadd_u8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u8(result), 0);
      exp = UINT64_C(0x7e437e3efeffff7f);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_737() {

{
   {
      uint16x4_t arg1;
      uint16x4_t arg2;
      uint16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"sum\", fnname = \"vpadd_u16\", rettype = \"uint16x4_t\", argtypes = \"[uint16x4_t,uint16x4_t]\", vals = [VectorVal [IntegerVal 0,IntegerVal 16592,IntegerVal 38330,IntegerVal 65535],VectorVal [IntegerVal 32767,IntegerVal 32767,IntegerVal 32768,IntegerVal 25973]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u16(UINT64_C(0xffff95ba40d00000));
      arg2 = vcreate_u16(UINT64_C(0x657580007fff7fff));
      clear_neon_saturated();
      //  Expect: "result" = e575fffe95b940d0
      result = vpadd_u16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u16(result), 0);
      exp = UINT64_C(0xe575fffe95b940d0);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_738() {

{
   {
      uint32x2_t arg1;
      uint32x2_t arg2;
      uint32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"sum\", fnname = \"vpadd_u32\", rettype = \"uint32x2_t\", argtypes = \"[uint32x2_t,uint32x2_t]\", vals = [VectorVal [IntegerVal 4294945933,IntegerVal 32768],VectorVal [IntegerVal 65535,IntegerVal 4294901760]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u32(UINT64_C(0x00008000ffffac8d));
      arg2 = vcreate_u32(UINT64_C(0xffff00000000ffff));
      clear_neon_saturated();
      //  Expect: "result" = ffffffff00002c8d
      result = vpadd_u32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u32(result), 0);
      exp = UINT64_C(0xffffffff00002c8d);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_739() {

{
   {
      float32x2_t arg1;
      float32x2_t arg2;
      float32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"sum\", fnname = \"vpadd_f32\", rettype = \"float32x2_t\", argtypes = \"[float32x2_t,float32x2_t]\", vals = [VectorVal [FloatVal 1.340264081954956e-2,FloatVal 8.961182832717896e-2],VectorVal [FloatVal 0.6365017890930176,FloatVal 0.8134191036224365]], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_f32(UINT64_C(0x3db786683c5b96c0));
      arg2 = vcreate_f32(UINT64_C(0x3f503c3c3f22f1c8));
      clear_neon_saturated();
      //  Expect: "result" = 3fb997023dd2f940
      result = vpadd_f32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result, 0);
         exp = ((float32_t) 0.10301446914672852);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result, 1);
         exp = ((float32_t) 1.449920892715454);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
   }
}
}
void dotests_740() {

{
   {
      int8x16_t arg1;
      int8x16_t arg2;
      int8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"sum\", fnname = \"vpaddq_s8\", rettype = \"int8x16_t\", argtypes = \"[int8x16_t,int8x16_t]\", vals = [VectorVal [IntegerVal (-128),IntegerVal (-14),IntegerVal (-27),IntegerVal 0,IntegerVal (-1),IntegerVal 0,IntegerVal (-128),IntegerVal 127,IntegerVal 127,IntegerVal 0,IntegerVal (-128),IntegerVal (-128),IntegerVal 0,IntegerVal (-128),IntegerVal (-1),IntegerVal (-1)],VectorVal [IntegerVal 0,IntegerVal (-125),IntegerVal 127,IntegerVal 0,IntegerVal 0,IntegerVal 0,IntegerVal 0,IntegerVal 127,IntegerVal 127,IntegerVal 127,IntegerVal 0,IntegerVal 0,IntegerVal (-128),IntegerVal 127,IntegerVal 0,IntegerVal 0]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s8(vcreate_s8(UINT64_C(0x7f8000ff00e5f280)),
                         vcreate_s8(UINT64_C(0xffff80008080007f)));
      arg2 = vcombine_s8(vcreate_s8(UINT64_C(0x7f000000007f8300)),
                         vcreate_s8(UINT64_C(0x00007f8000007f7f)));
      clear_neon_saturated();
      //  Expect: "result" = 00ff00fe7f007f83fe80007fffffe572
      result = vpaddq_s8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result), 0);
         exp = UINT64_C(0xfe80007fffffe572);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result), 1);
         exp = UINT64_C(0x00ff00fe7f007f83);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_741() {

{
   {
      int16x8_t arg1;
      int16x8_t arg2;
      int16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"sum\", fnname = \"vpaddq_s16\", rettype = \"int16x8_t\", argtypes = \"[int16x8_t,int16x8_t]\", vals = [VectorVal [IntegerVal 32767,IntegerVal 32767,IntegerVal (-32768),IntegerVal 0,IntegerVal 32767,IntegerVal 32767,IntegerVal (-22343),IntegerVal 28821],VectorVal [IntegerVal (-32768),IntegerVal 22387,IntegerVal (-32768),IntegerVal 32767,IntegerVal (-1),IntegerVal 0,IntegerVal (-32768),IntegerVal (-32768)]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s16(vcreate_s16(UINT64_C(0x000080007fff7fff)),
                          vcreate_s16(UINT64_C(0x7095a8b97fff7fff)));
      arg2 = vcombine_s16(vcreate_s16(UINT64_C(0x7fff800057738000)),
                          vcreate_s16(UINT64_C(0x800080000000ffff)));
      clear_neon_saturated();
      //  Expect: "result" = 0000ffffffffd773194efffe8000fffe
      result = vpaddq_s16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 0);
         exp = UINT64_C(0x194efffe8000fffe);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 1);
         exp = UINT64_C(0x0000ffffffffd773);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_742() {

{
   {
      int32x4_t arg1;
      int32x4_t arg2;
      int32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"sum\", fnname = \"vpaddq_s32\", rettype = \"int32x4_t\", argtypes = \"[int32x4_t,int32x4_t]\", vals = [VectorVal [IntegerVal (-2147450881),IntegerVal (-2147450880),IntegerVal (-694681601),IntegerVal (-32768)],VectorVal [IntegerVal 1807548416,IntegerVal (-65536),IntegerVal 2147418112,IntegerVal (-45426)]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s32(vcreate_s32(UINT64_C(0x8000800080007fff)),
                          vcreate_s32(UINT64_C(0xffff8000d697ffff)));
      arg2 = vcombine_s32(vcreate_s32(UINT64_C(0xffff00006bbd0000)),
                          vcreate_s32(UINT64_C(0xffff4e8e7fff0000)));
      clear_neon_saturated();
      //  Expect: "result" = 7ffe4e8e6bbc0000d6977fff0000ffff
      result = vpaddq_s32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 0);
         exp = UINT64_C(0xd6977fff0000ffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 1);
         exp = UINT64_C(0x7ffe4e8e6bbc0000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_743() {

{
   {
      int64x2_t arg1;
      int64x2_t arg2;
      int64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"sum\", fnname = \"vpaddq_s64\", rettype = \"int64x2_t\", argtypes = \"[int64x2_t,int64x2_t]\", vals = [VectorVal [IntegerVal (-9223090565701435393),IntegerVal 140737488388095],VectorVal [IntegerVal (-140739635838976),IntegerVal (-140735340904448)]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s64(vcreate_s64(UINT64_C(0x8000ffff1c1bffff)),
                          vcreate_s64(UINT64_C(0x0000800000007fff)));
      arg2 = vcombine_s64(vcreate_s64(UINT64_C(0xffff7fff80000000)),
                          vcreate_s64(UINT64_C(0xffff80007fff8000)));
      clear_neon_saturated();
      //  Expect: "result" = fffeffffffff800080017fff1c1c7ffe
      result = vpaddq_s64(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 0);
         exp = UINT64_C(0x80017fff1c1c7ffe);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 1);
         exp = UINT64_C(0xfffeffffffff8000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_744() {

{
   {
      uint8x16_t arg1;
      uint8x16_t arg2;
      uint8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"sum\", fnname = \"vpaddq_u8\", rettype = \"uint8x16_t\", argtypes = \"[uint8x16_t,uint8x16_t]\", vals = [VectorVal [IntegerVal 128,IntegerVal 127,IntegerVal 255,IntegerVal 0,IntegerVal 0,IntegerVal 127,IntegerVal 128,IntegerVal 0,IntegerVal 255,IntegerVal 128,IntegerVal 245,IntegerVal 127,IntegerVal 172,IntegerVal 128,IntegerVal 0,IntegerVal 127],VectorVal [IntegerVal 127,IntegerVal 255,IntegerVal 127,IntegerVal 116,IntegerVal 255,IntegerVal 127,IntegerVal 0,IntegerVal 240,IntegerVal 255,IntegerVal 255,IntegerVal 0,IntegerVal 127,IntegerVal 128,IntegerVal 113,IntegerVal 0,IntegerVal 0]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u8(vcreate_u8(UINT64_C(0x00807f0000ff7f80)),
                         vcreate_u8(UINT64_C(0x7f0080ac7ff580ff)));
      arg2 = vcombine_u8(vcreate_u8(UINT64_C(0xf0007fff747fff7f)),
                         vcreate_u8(UINT64_C(0x000071807f00ffff)));
      clear_neon_saturated();
      //  Expect: "result" = 00f17ffef07ef37e7f2c747f807fffff
      result = vpaddq_u8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 0);
         exp = UINT64_C(0x7f2c747f807fffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 1);
         exp = UINT64_C(0x00f17ffef07ef37e);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_745() {

{
   {
      uint16x8_t arg1;
      uint16x8_t arg2;
      uint16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"sum\", fnname = \"vpaddq_u16\", rettype = \"uint16x8_t\", argtypes = \"[uint16x8_t,uint16x8_t]\", vals = [VectorVal [IntegerVal 45810,IntegerVal 32768,IntegerVal 0,IntegerVal 9256,IntegerVal 0,IntegerVal 8523,IntegerVal 32767,IntegerVal 61748],VectorVal [IntegerVal 32767,IntegerVal 15845,IntegerVal 0,IntegerVal 65535,IntegerVal 32768,IntegerVal 0,IntegerVal 65535,IntegerVal 32768]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u16(vcreate_u16(UINT64_C(0x242800008000b2f2)),
                          vcreate_u16(UINT64_C(0xf1347fff214b0000)));
      arg2 = vcombine_u16(vcreate_u16(UINT64_C(0xffff00003de57fff)),
                          vcreate_u16(UINT64_C(0x8000ffff00008000)));
      clear_neon_saturated();
      //  Expect: "result" = 7fff8000ffffbde47133214b242832f2
      result = vpaddq_u16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 0);
         exp = UINT64_C(0x7133214b242832f2);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 1);
         exp = UINT64_C(0x7fff8000ffffbde4);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_746() {

{
   {
      uint32x4_t arg1;
      uint32x4_t arg2;
      uint32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"sum\", fnname = \"vpaddq_u32\", rettype = \"uint32x4_t\", argtypes = \"[uint32x4_t,uint32x4_t]\", vals = [VectorVal [IntegerVal 4294934527,IntegerVal 2147483647,IntegerVal 2147448495,IntegerVal 4294934527],VectorVal [IntegerVal 513707481,IntegerVal 18973,IntegerVal 4294967295,IntegerVal 2147483647]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u32(vcreate_u32(UINT64_C(0x7fffffffffff7fff)),
                          vcreate_u32(UINT64_C(0xffff7fff7fff76af)));
      arg2 = vcombine_u32(vcreate_u32(UINT64_C(0x00004a1d1e9e8dd9)),
                          vcreate_u32(UINT64_C(0x7fffffffffffffff)));
      clear_neon_saturated();
      //  Expect: "result" = 7ffffffe1e9ed7f67ffef6ae7fff7ffe
      result = vpaddq_u32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 0);
         exp = UINT64_C(0x7ffef6ae7fff7ffe);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 1);
         exp = UINT64_C(0x7ffffffe1e9ed7f6);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_747() {

{
   {
      uint64x2_t arg1;
      uint64x2_t arg2;
      uint64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"sum\", fnname = \"vpaddq_u64\", rettype = \"uint64x2_t\", argtypes = \"[uint64x2_t,uint64x2_t]\", vals = [VectorVal [IntegerVal 9223090566023806976,IntegerVal 70164733165568],VectorVal [IntegerVal 281472829194240,IntegerVal 9223653507536551935]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u64(vcreate_u64(UINT64_C(0x7fff0000f71b0000)),
                          vcreate_u64(UINT64_C(0x00003fd07fff0000)));
      arg2 = vcombine_u64(vcreate_u64(UINT64_C(0x0000ffff7fff8000)),
                          vcreate_u64(UINT64_C(0x8000ffff00007fff)));
      clear_neon_saturated();
      //  Expect: "result" = 8001fffe7fffffff7fff3fd1771a0000
      result = vpaddq_u64(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 0);
         exp = UINT64_C(0x7fff3fd1771a0000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 1);
         exp = UINT64_C(0x8001fffe7fffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_748() {

{
   {
      float32x4_t arg1;
      float32x4_t arg2;
      float32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"sum\", fnname = \"vpaddq_f32\", rettype = \"float32x4_t\", argtypes = \"[float32x4_t,float32x4_t]\", vals = [VectorVal [FloatVal 0.3141857385635376,FloatVal 0.8018496036529541,FloatVal 0.14677822589874268,FloatVal 0.9431734085083008],VectorVal [FloatVal 0.7379448413848877,FloatVal 0.311360239982605,FloatVal 0.5274255871772766,FloatVal 0.8807608485221863]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_f32(vcreate_f32(UINT64_C(0x3f4d46043ea0dcf4)),
                          vcreate_f32(UINT64_C(0x3f7173d03e164d08)));
      arg2 = vcombine_f32(vcreate_f32(UINT64_C(0x3e9f6a9c3f3ce9f4)),
                          vcreate_f32(UINT64_C(0x3f61798b3f07055d)));
      clear_neon_saturated();
      //  Expect: "result" = 3fb43f743f864fa13f8b83893f8eda3f
      result = vpaddq_f32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 0);
         exp = ((float32_t) 1.1160353422164917);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 1);
         exp = ((float32_t) 1.0899516344070435);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 2);
         exp = ((float32_t) 1.0493050813674927);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 2 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 3);
         exp = ((float32_t) 1.408186435699463);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 3 ", exp, got);
            }
      }
   }
}
}
void dotests_749() {

{
   {
      float64x2_t arg1;
      float64x2_t arg2;
      float64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"sum\", fnname = \"vpaddq_f64\", rettype = \"float64x2_t\", argtypes = \"[float64x2_t,float64x2_t]\", vals = [VectorVal [FloatVal 0.39879799213949485,FloatVal 0.22101207256652589],VectorVal [FloatVal 0.3242278301661825,FloatVal 0.6321927762050913]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_f64(vcreate_f64(UINT64_C(0x3fd985e8037cc62c)),
                          vcreate_f64(UINT64_C(0x3fcc4a1fa3d8e258)));
      arg2 = vcombine_f64(vcreate_f64(UINT64_C(0x3fd4c02615c11330)),
                          vcreate_f64(UINT64_C(0x3fe43aec58522fa1)));
      clear_neon_saturated();
      //  Expect: "result" = 3fee9aff6332b9393fe3d57beab49bac
      result = vpaddq_f64(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float64_t got;
         float64_t exp;
         got = vgetq_lane_f64(result, 0);
         exp = 0.6198100647060207;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float64_t got;
         float64_t exp;
         got = vgetq_lane_f64(result, 1);
         exp = 0.9564206063712738;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
   }
}
}
void dotests_750() {

{
   {
      int64x2_t arg1;
      int64_t result;
      char* str1 = "ReproInfo2 {semantics = \"sum\", fnname = \"vpaddd_s64\", rettype = \"int64_t\", argtypes = \"[int64x2_t]\", vals = [VectorVal [IntegerVal 140733193419386,IntegerVal (-140739635806209)]], start_saturated = False}";
      int reported = 0;
      int64_t got;
      int64_t exp;
      arg1 = vcombine_s64(vcreate_s64(UINT64_C(0x00007fff00007a7a)),
                          vcreate_s64(UINT64_C(0xffff7fff80007fff)));
      clear_neon_saturated();
      //  Expect: "result" = fffffffe8000fa79
      result = vpaddd_s64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = INT64_C(-6442386823);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIi64 " Got: %" PRIi64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_751() {

{
   {
      uint64x2_t arg1;
      uint64_t result;
      char* str1 = "ReproInfo2 {semantics = \"sum\", fnname = \"vpaddd_u64\", rettype = \"uint64_t\", argtypes = \"[uint64x2_t]\", vals = [VectorVal [IntegerVal 140739635806207,IntegerVal 9223512774343119804]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcombine_u64(vcreate_u64(UINT64_C(0x000080007fff7fff)),
                          vcreate_u64(UINT64_C(0x80007fffffffd3bc)));
      clear_neon_saturated();
      //  Expect: "result" = 800100007fff53bb
      result = vpaddd_u64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = UINT64_C(0x800100007fff53bb);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_752() {

{
   {
      float32x2_t arg1;
      float32_t result;
      char* str1 = "ReproInfo2 {semantics = \"sum\", fnname = \"vpadds_f32\", rettype = \"float32_t\", argtypes = \"[float32x2_t]\", vals = [VectorVal [FloatVal 0.9263191819190979,FloatVal 0.9758244156837463]], start_saturated = False}";
      int reported = 0;
      float32_t got;
      float32_t exp;
      arg1 = vcreate_f32(UINT64_C(0x3f79cfa13f6d2341));
      clear_neon_saturated();
      //  Expect: "result" = 3ff37971
      result = vpadds_f32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = ((float32_t) 1.9021435976028442);
      if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %f Got: %f\n", "   ", exp, got);
         }
   }
}
}
void dotests_753() {

{
   {
      float64x2_t arg1;
      float64_t result;
      char* str1 = "ReproInfo2 {semantics = \"sum\", fnname = \"vpaddd_f64\", rettype = \"float64_t\", argtypes = \"[float64x2_t]\", vals = [VectorVal [FloatVal 0.21273825053095397,FloatVal 0.1313816960378078]], start_saturated = True}";
      int reported = 0;
      float64_t got;
      float64_t exp;
      arg1 = vcombine_f64(vcreate_f64(UINT64_C(0x3fcb3b01ca51c0fc)),
                          vcreate_f64(UINT64_C(0x3fc0d11d8be34038)));
      set_neon_saturated();
      //  Expect: "result" = 3fd6060fab1a809a
      result = vpaddd_f64(arg1);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      got = result;
      exp = 0.34411994656876177;
      if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %f Got: %f\n", "   ", exp, got);
         }
   }
}
}
void dotests_754() {

{
   {
      int8x8_t arg1;
      int16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"sum\", fnname = \"vpaddl_s8\", rettype = \"int16x4_t\", argtypes = \"[int8x8_t]\", vals = [VectorVal [IntegerVal (-117),IntegerVal (-1),IntegerVal 127,IntegerVal 0,IntegerVal 127,IntegerVal (-128),IntegerVal (-128),IntegerVal 0]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s8(UINT64_C(0x0080807f007fff8b));
      clear_neon_saturated();
      //  Expect: "result" = ff80ffff007fff8a
      result = vpaddl_s8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s16(result), 0);
      exp = UINT64_C(0xff80ffff007fff8a);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_755() {

{
   {
      int16x4_t arg1;
      int32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"sum\", fnname = \"vpaddl_s16\", rettype = \"int32x2_t\", argtypes = \"[int16x4_t]\", vals = [VectorVal [IntegerVal (-1),IntegerVal 1232,IntegerVal (-32706),IntegerVal (-13468)]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s16(UINT64_C(0xcb64803e04d0ffff));
      clear_neon_saturated();
      //  Expect: "result" = ffff4ba2000004cf
      result = vpaddl_s16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s32(result), 0);
      exp = UINT64_C(0xffff4ba2000004cf);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_756() {

{
   {
      int32x2_t arg1;
      int64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"sum\", fnname = \"vpaddl_s32\", rettype = \"int64x1_t\", argtypes = \"[int32x2_t]\", vals = [VectorVal [IntegerVal (-1733361664),IntegerVal 1516732415]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s32(UINT64_C(0x5a677fff98af0000));
      clear_neon_saturated();
      //  Expect: "result" = fffffffff3167fff
      result = vpaddl_s32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s64(result), 0);
      exp = UINT64_C(0xfffffffff3167fff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_757() {

{
   {
      uint8x8_t arg1;
      uint16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"sum\", fnname = \"vpaddl_u8\", rettype = \"uint16x4_t\", argtypes = \"[uint8x8_t]\", vals = [VectorVal [IntegerVal 128,IntegerVal 128,IntegerVal 0,IntegerVal 255,IntegerVal 0,IntegerVal 127,IntegerVal 128,IntegerVal 188]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u8(UINT64_C(0xbc807f00ff008080));
      clear_neon_saturated();
      //  Expect: "result" = 013c007f00ff0100
      result = vpaddl_u8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u16(result), 0);
      exp = UINT64_C(0x013c007f00ff0100);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_758() {

{
   {
      uint16x4_t arg1;
      uint32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"sum\", fnname = \"vpaddl_u16\", rettype = \"uint32x2_t\", argtypes = \"[uint16x4_t]\", vals = [VectorVal [IntegerVal 65535,IntegerVal 32768,IntegerVal 0,IntegerVal 51006]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u16(UINT64_C(0xc73e00008000ffff));
      clear_neon_saturated();
      //  Expect: "result" = 0000c73e00017fff
      result = vpaddl_u16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u32(result), 0);
      exp = UINT64_C(0x0000c73e00017fff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_759() {

{
   {
      uint32x2_t arg1;
      uint64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"sum\", fnname = \"vpaddl_u32\", rettype = \"uint64x1_t\", argtypes = \"[uint32x2_t]\", vals = [VectorVal [IntegerVal 2147483647,IntegerVal 2147418112]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u32(UINT64_C(0x7fff00007fffffff));
      clear_neon_saturated();
      //  Expect: "result" = 00000000fffeffff
      result = vpaddl_u32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(result, 0);
      exp = UINT64_C(0x00000000fffeffff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_760() {

{
   {
      int8x16_t arg1;
      int16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"sum\", fnname = \"vpaddlq_s8\", rettype = \"int16x8_t\", argtypes = \"[int8x16_t]\", vals = [VectorVal [IntegerVal 0,IntegerVal 0,IntegerVal (-1),IntegerVal 93,IntegerVal (-1),IntegerVal 0,IntegerVal (-1),IntegerVal 127,IntegerVal 4,IntegerVal (-1),IntegerVal 127,IntegerVal 127,IntegerVal 127,IntegerVal (-128),IntegerVal 0,IntegerVal (-1)]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s8(vcreate_s8(UINT64_C(0x7fff00ff5dff0000)),
                         vcreate_s8(UINT64_C(0xff00807f7f7fff04)));
      clear_neon_saturated();
      //  Expect: "result" = ffffffff00fe0003007effff005c0000
      result = vpaddlq_s8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 0);
         exp = UINT64_C(0x007effff005c0000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 1);
         exp = UINT64_C(0xffffffff00fe0003);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_761() {

{
   {
      int16x8_t arg1;
      int32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"sum\", fnname = \"vpaddlq_s16\", rettype = \"int32x4_t\", argtypes = \"[int16x8_t]\", vals = [VectorVal [IntegerVal (-32768),IntegerVal 32767,IntegerVal 0,IntegerVal 32767,IntegerVal (-32768),IntegerVal 0,IntegerVal 0,IntegerVal 32767]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s16(vcreate_s16(UINT64_C(0x7fff00007fff8000)),
                          vcreate_s16(UINT64_C(0x7fff000000008000)));
      clear_neon_saturated();
      //  Expect: "result" = 00007fffffff800000007fffffffffff
      result = vpaddlq_s16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 0);
         exp = UINT64_C(0x00007fffffffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 1);
         exp = UINT64_C(0x00007fffffff8000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_762() {

{
   {
      int32x4_t arg1;
      int64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"sum\", fnname = \"vpaddlq_s32\", rettype = \"int64x2_t\", argtypes = \"[int32x4_t]\", vals = [VectorVal [IntegerVal (-873922560),IntegerVal 2147418112,IntegerVal 0,IntegerVal 0]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s32(vcreate_s32(UINT64_C(0x7fff0000cbe90000)),
                          vcreate_s32(0));
      clear_neon_saturated();
      //  Expect: "result" = 0000000000000000000000004be80000
      result = vpaddlq_s32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 0);
         exp = UINT64_C(0x000000004be80000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 1);
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_763() {

{
   {
      uint8x16_t arg1;
      uint16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"sum\", fnname = \"vpaddlq_u8\", rettype = \"uint16x8_t\", argtypes = \"[uint8x16_t]\", vals = [VectorVal [IntegerVal 128,IntegerVal 168,IntegerVal 255,IntegerVal 127,IntegerVal 0,IntegerVal 255,IntegerVal 89,IntegerVal 132,IntegerVal 127,IntegerVal 255,IntegerVal 12,IntegerVal 0,IntegerVal 127,IntegerVal 0,IntegerVal 127,IntegerVal 127]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u8(vcreate_u8(UINT64_C(0x8459ff007fffa880)),
                         vcreate_u8(UINT64_C(0x7f7f007f000cff7f)));
      clear_neon_saturated();
      //  Expect: "result" = 00fe007f000c017e00dd00ff017e0128
      result = vpaddlq_u8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 0);
         exp = UINT64_C(0x00dd00ff017e0128);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 1);
         exp = UINT64_C(0x00fe007f000c017e);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_764() {

{
   {
      uint16x8_t arg1;
      uint32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"sum\", fnname = \"vpaddlq_u16\", rettype = \"uint32x4_t\", argtypes = \"[uint16x8_t]\", vals = [VectorVal [IntegerVal 32767,IntegerVal 65535,IntegerVal 0,IntegerVal 4172,IntegerVal 32768,IntegerVal 32767,IntegerVal 0,IntegerVal 62470]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u16(vcreate_u16(UINT64_C(0x104c0000ffff7fff)),
                          vcreate_u16(UINT64_C(0xf40600007fff8000)));
      clear_neon_saturated();
      //  Expect: "result" = 0000f4060000ffff0000104c00017ffe
      result = vpaddlq_u16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 0);
         exp = UINT64_C(0x0000104c00017ffe);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 1);
         exp = UINT64_C(0x0000f4060000ffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_765() {

{
   {
      uint32x4_t arg1;
      uint64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"sum\", fnname = \"vpaddlq_u32\", rettype = \"uint64x2_t\", argtypes = \"[uint32x4_t]\", vals = [VectorVal [IntegerVal 2359263232,IntegerVal 4294934527,IntegerVal 2147514725,IntegerVal 4294967295]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u32(vcreate_u32(UINT64_C(0xffff7fff8c9f8000)),
                          vcreate_u32(UINT64_C(0xffffffff80007965)));
      clear_neon_saturated();
      //  Expect: "result" = 0000000180007964000000018c9effff
      result = vpaddlq_u32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 0);
         exp = UINT64_C(0x000000018c9effff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 1);
         exp = UINT64_C(0x0000000180007964);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_766() {

{
   {
      int16x4_t arg1;
      int8x8_t arg2;
      int16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"sma\", fnname = \"vpadal_s8\", rettype = \"int16x4_t\", argtypes = \"[int16x4_t,int8x8_t]\", vals = [VectorVal [IntegerVal 32767,IntegerVal 0,IntegerVal 32767,IntegerVal (-1)],VectorVal [IntegerVal 49,IntegerVal (-16),IntegerVal 127,IntegerVal (-128),IntegerVal (-1),IntegerVal 0,IntegerVal (-1),IntegerVal (-52)]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s16(UINT64_C(0xffff7fff00007fff));
      arg2 = vcreate_s8(UINT64_C(0xccff00ff807ff031));
      clear_neon_saturated();
      //  Expect: "result" = ffca7ffeffff8020
      result = vpadal_s8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s16(result), 0);
      exp = UINT64_C(0xffca7ffeffff8020);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_767() {

{
   {
      int32x2_t arg1;
      int16x4_t arg2;
      int32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"sma\", fnname = \"vpadal_s16\", rettype = \"int32x2_t\", argtypes = \"[int32x2_t,int16x4_t]\", vals = [VectorVal [IntegerVal 65535,IntegerVal 2147482123],VectorVal [IntegerVal 0,IntegerVal (-32768),IntegerVal (-1),IntegerVal 0]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s32(UINT64_C(0x7ffffa0b0000ffff));
      arg2 = vcreate_s16(UINT64_C(0x0000ffff80000000));
      clear_neon_saturated();
      //  Expect: "result" = 7ffffa0a00007fff
      result = vpadal_s16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s32(result), 0);
      exp = UINT64_C(0x7ffffa0a00007fff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_768() {

{
   {
      int64x1_t arg1;
      int32x2_t arg2;
      int64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"sma\", fnname = \"vpadal_s32\", rettype = \"int64x1_t\", argtypes = \"[int64x1_t,int32x2_t]\", vals = [VectorVal [IntegerVal 9223090566172966912],VectorVal [IntegerVal (-2147483648),IntegerVal 32768]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s64(UINT64_C(0x7fff0000ffff0000));
      arg2 = vcreate_s32(UINT64_C(0x0000800080000000));
      clear_neon_saturated();
      //  Expect: "result" = 7fff00007fff8000
      result = vpadal_s32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s64(result), 0);
      exp = UINT64_C(0x7fff00007fff8000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_769() {

{
   {
      uint16x4_t arg1;
      uint8x8_t arg2;
      uint16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"sma\", fnname = \"vpadal_u8\", rettype = \"uint16x4_t\", argtypes = \"[uint16x4_t,uint8x8_t]\", vals = [VectorVal [IntegerVal 65535,IntegerVal 65535,IntegerVal 61205,IntegerVal 32768],VectorVal [IntegerVal 0,IntegerVal 0,IntegerVal 255,IntegerVal 255,IntegerVal 127,IntegerVal 0,IntegerVal 255,IntegerVal 255]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u16(UINT64_C(0x8000ef15ffffffff));
      arg2 = vcreate_u8(UINT64_C(0xffff007fffff0000));
      clear_neon_saturated();
      //  Expect: "result" = 81feef9401fdffff
      result = vpadal_u8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u16(result), 0);
      exp = UINT64_C(0x81feef9401fdffff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_770() {

{
   {
      uint32x2_t arg1;
      uint16x4_t arg2;
      uint32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"sma\", fnname = \"vpadal_u16\", rettype = \"uint32x2_t\", argtypes = \"[uint32x2_t,uint16x4_t]\", vals = [VectorVal [IntegerVal 2147459610,IntegerVal 4294934527],VectorVal [IntegerVal 65535,IntegerVal 65535,IntegerVal 65535,IntegerVal 65535]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u32(UINT64_C(0xffff7fff7fffa21a));
      arg2 = vcreate_u16(UINT64_C(0xffffffffffffffff));
      clear_neon_saturated();
      //  Expect: "result" = 00017ffd8001a218
      result = vpadal_u16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u32(result), 0);
      exp = UINT64_C(0x00017ffd8001a218);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_771() {

{
   {
      uint64x1_t arg1;
      uint32x2_t arg2;
      uint64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"sma\", fnname = \"vpadal_u32\", rettype = \"uint64x1_t\", argtypes = \"[uint64x1_t,uint32x2_t]\", vals = [VectorVal [IntegerVal 9223372041064756942],VectorVal [IntegerVal 4294934527,IntegerVal 2147516416]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u64(UINT64_C(0x80000000faef36ce));
      arg2 = vcreate_u32(UINT64_C(0x80008000ffff7fff));
      clear_neon_saturated();
      //  Expect: "result" = 800000027aef36cd
      result = vpadal_u32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(result, 0);
      exp = UINT64_C(0x800000027aef36cd);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_772() {

{
   {
      int16x8_t arg1;
      int8x16_t arg2;
      int16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"sma\", fnname = \"vpadalq_s8\", rettype = \"int16x8_t\", argtypes = \"[int16x8_t,int8x16_t]\", vals = [VectorVal [IntegerVal 32767,IntegerVal (-32768),IntegerVal 32767,IntegerVal (-16377),IntegerVal 0,IntegerVal 0,IntegerVal (-32768),IntegerVal (-32768)],VectorVal [IntegerVal (-1),IntegerVal 127,IntegerVal (-128),IntegerVal 127,IntegerVal 3,IntegerVal (-46),IntegerVal 0,IntegerVal 127,IntegerVal 0,IntegerVal 0,IntegerVal 127,IntegerVal (-32),IntegerVal 127,IntegerVal 0,IntegerVal (-1),IntegerVal (-28)]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s16(vcreate_s16(UINT64_C(0xc0077fff80007fff)),
                          vcreate_s16(UINT64_C(0x8000800000000000)));
      arg2 = vcombine_s8(vcreate_s8(UINT64_C(0x7f00d2037f807fff)),
                         vcreate_s8(UINT64_C(0xe4ff007fe07f0000)));
      clear_neon_saturated();
      //  Expect: "result" = 7fe3807f005f0000c0867fd47fff807d
      result = vpadalq_s8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 0);
         exp = UINT64_C(0xc0867fd47fff807d);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 1);
         exp = UINT64_C(0x7fe3807f005f0000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_773() {

{
   {
      int32x4_t arg1;
      int16x8_t arg2;
      int32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"sma\", fnname = \"vpadalq_s16\", rettype = \"int32x4_t\", argtypes = \"[int32x4_t,int16x8_t]\", vals = [VectorVal [IntegerVal (-32768),IntegerVal 0,IntegerVal (-2147483648),IntegerVal 2147450880],VectorVal [IntegerVal 0,IntegerVal (-32768),IntegerVal 0,IntegerVal (-32768),IntegerVal (-8597),IntegerVal 32767,IntegerVal 32767,IntegerVal (-1)]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s32(vcreate_s32(UINT64_C(0x00000000ffff8000)),
                          vcreate_s32(UINT64_C(0x7fff800080000000)));
      arg2 = vcombine_s16(vcreate_s16(UINT64_C(0x8000000080000000)),
                          vcreate_s16(UINT64_C(0xffff7fff7fffde6b)));
      clear_neon_saturated();
      //  Expect: "result" = 7ffffffe80005e6affff8000ffff0000
      result = vpadalq_s16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 0);
         exp = UINT64_C(0xffff8000ffff0000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 1);
         exp = UINT64_C(0x7ffffffe80005e6a);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_774() {

{
   {
      int64x2_t arg1;
      int32x4_t arg2;
      int64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"sma\", fnname = \"vpadalq_s32\", rettype = \"int64x2_t\", argtypes = \"[int64x2_t,int32x4_t]\", vals = [VectorVal [IntegerVal 9223324319768182783,IntegerVal 281472829194239],VectorVal [IntegerVal (-65536),IntegerVal (-65536),IntegerVal (-2147450881),IntegerVal (-2147449123)]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s64(vcreate_s64(UINT64_C(0x7fffd49a0000ffff)),
                          vcreate_s64(UINT64_C(0x0000ffff7fff7fff)));
      arg2 = vcombine_s32(vcreate_s32(UINT64_C(0xffff0000ffff0000)),
                          vcreate_s32(UINT64_C(0x800086dd80007fff)));
      clear_neon_saturated();
      //  Expect: "result" = 0000fffe800086db7fffd499fffeffff
      result = vpadalq_s32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 0);
         exp = UINT64_C(0x7fffd499fffeffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 1);
         exp = UINT64_C(0x0000fffe800086db);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_775() {

{
   {
      uint16x8_t arg1;
      uint8x16_t arg2;
      uint16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"sma\", fnname = \"vpadalq_u8\", rettype = \"uint16x8_t\", argtypes = \"[uint16x8_t,uint8x16_t]\", vals = [VectorVal [IntegerVal 28110,IntegerVal 57930,IntegerVal 19215,IntegerVal 65535,IntegerVal 0,IntegerVal 0,IntegerVal 0,IntegerVal 32768],VectorVal [IntegerVal 127,IntegerVal 0,IntegerVal 255,IntegerVal 127,IntegerVal 127,IntegerVal 128,IntegerVal 123,IntegerVal 127,IntegerVal 0,IntegerVal 128,IntegerVal 0,IntegerVal 218,IntegerVal 128,IntegerVal 255,IntegerVal 255,IntegerVal 127]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u16(vcreate_u16(UINT64_C(0xffff4b0fe24a6dce)),
                          vcreate_u16(UINT64_C(0x8000000000000000)));
      arg2 = vcombine_u8(vcreate_u8(UINT64_C(0x7f7b807f7fff007f)),
                         vcreate_u8(UINT64_C(0x7fffff80da008000)));
      clear_neon_saturated();
      //  Expect: "result" = 817e017f00da008000f94c0ee3c86e4d
      result = vpadalq_u8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 0);
         exp = UINT64_C(0x00f94c0ee3c86e4d);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 1);
         exp = UINT64_C(0x817e017f00da0080);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_776() {

{
   {
      uint32x4_t arg1;
      uint16x8_t arg2;
      uint32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"sma\", fnname = \"vpadalq_u16\", rettype = \"uint32x4_t\", argtypes = \"[uint32x4_t,uint16x8_t]\", vals = [VectorVal [IntegerVal 4294934527,IntegerVal 584687356,IntegerVal 0,IntegerVal 4294934528],VectorVal [IntegerVal 65535,IntegerVal 0,IntegerVal 29731,IntegerVal 57801,IntegerVal 65535,IntegerVal 32767,IntegerVal 32767,IntegerVal 32767]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u32(vcreate_u32(UINT64_C(0x22d99efcffff7fff)),
                          vcreate_u32(UINT64_C(0xffff800000000000)));
      arg2 = vcombine_u16(vcreate_u16(UINT64_C(0xe1c974230000ffff)),
                          vcreate_u16(UINT64_C(0x7fff7fff7fffffff)));
      clear_neon_saturated();
      //  Expect: "result" = 00007ffe00017ffe22daf4e800007ffe
      result = vpadalq_u16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 0);
         exp = UINT64_C(0x22daf4e800007ffe);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 1);
         exp = UINT64_C(0x00007ffe00017ffe);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_777() {

{
   {
      uint64x2_t arg1;
      uint32x4_t arg2;
      uint64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"sma\", fnname = \"vpadalq_u32\", rettype = \"uint64x2_t\", argtypes = \"[uint64x2_t,uint32x4_t]\", vals = [VectorVal [IntegerVal 4737364597721563136,IntegerVal 18446462600832909311],VectorVal [IntegerVal 45842431,IntegerVal 2147450879,IntegerVal 2147483647,IntegerVal 2147483648]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u64(vcreate_u64(UINT64_C(0x41be800082b48000)),
                          vcreate_u64(UINT64_C(0xffff00007d2c7fff)));
      arg2 = vcombine_u32(vcreate_u32(UINT64_C(0x7fff7fff02bb7fff)),
                          vcreate_u32(UINT64_C(0x800000007fffffff)));
      clear_neon_saturated();
      //  Expect: "result" = ffff00017d2c7ffe41be8001056f7ffe
      result = vpadalq_u32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 0);
         exp = UINT64_C(0x41be8001056f7ffe);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 1);
         exp = UINT64_C(0xffff00017d2c7ffe);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_778() {

{
   {
      int8x8_t arg1;
      int8x8_t arg2;
      int8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"fmx\", fnname = \"vpmax_s8\", rettype = \"int8x8_t\", argtypes = \"[int8x8_t,int8x8_t]\", vals = [VectorVal [IntegerVal (-128),IntegerVal (-1),IntegerVal (-108),IntegerVal 127,IntegerVal (-128),IntegerVal (-1),IntegerVal 127,IntegerVal 0],VectorVal [IntegerVal (-128),IntegerVal 127,IntegerVal 0,IntegerVal 0,IntegerVal (-92),IntegerVal 0,IntegerVal 0,IntegerVal 0]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s8(UINT64_C(0x007fff807f94ff80));
      arg2 = vcreate_s8(UINT64_C(0x000000a400007f80));
      clear_neon_saturated();
      //  Expect: "result" = 0000007f7fff7fff
      result = vpmax_s8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s8(result), 0);
      exp = UINT64_C(0x0000007f7fff7fff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_779() {

{
   {
      int16x4_t arg1;
      int16x4_t arg2;
      int16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"fmx\", fnname = \"vpmax_s16\", rettype = \"int16x4_t\", argtypes = \"[int16x4_t,int16x4_t]\", vals = [VectorVal [IntegerVal (-1),IntegerVal (-1),IntegerVal 0,IntegerVal 14547],VectorVal [IntegerVal 15191,IntegerVal 0,IntegerVal (-1),IntegerVal 0]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s16(UINT64_C(0x38d30000ffffffff));
      arg2 = vcreate_s16(UINT64_C(0x0000ffff00003b57));
      clear_neon_saturated();
      //  Expect: "result" = 00003b5738d3ffff
      result = vpmax_s16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s16(result), 0);
      exp = UINT64_C(0x00003b5738d3ffff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_780() {

{
   {
      int32x2_t arg1;
      int32x2_t arg2;
      int32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"fmx\", fnname = \"vpmax_s32\", rettype = \"int32x2_t\", argtypes = \"[int32x2_t,int32x2_t]\", vals = [VectorVal [IntegerVal (-522846208),IntegerVal 2147483647],VectorVal [IntegerVal 2147450880,IntegerVal 2147460503]], start_saturated = True}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s32(UINT64_C(0x7fffffffe0d60000));
      arg2 = vcreate_s32(UINT64_C(0x7fffa5977fff8000));
      set_neon_saturated();
      //  Expect: "result" = 7fffa5977fffffff
      result = vpmax_s32(arg1, arg2);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s32(result), 0);
      exp = UINT64_C(0x7fffa5977fffffff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_781() {

{
   {
      uint8x8_t arg1;
      uint8x8_t arg2;
      uint8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"fmx\", fnname = \"vpmax_u8\", rettype = \"uint8x8_t\", argtypes = \"[uint8x8_t,uint8x8_t]\", vals = [VectorVal [IntegerVal 30,IntegerVal 103,IntegerVal 255,IntegerVal 36,IntegerVal 6,IntegerVal 128,IntegerVal 0,IntegerVal 255],VectorVal [IntegerVal 128,IntegerVal 127,IntegerVal 189,IntegerVal 128,IntegerVal 127,IntegerVal 128,IntegerVal 128,IntegerVal 188]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u8(UINT64_C(0xff00800624ff671e));
      arg2 = vcreate_u8(UINT64_C(0xbc80807f80bd7f80));
      clear_neon_saturated();
      //  Expect: "result" = bc80bd80ff80ff67
      result = vpmax_u8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u8(result), 0);
      exp = UINT64_C(0xbc80bd80ff80ff67);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_782() {

{
   {
      uint16x4_t arg1;
      uint16x4_t arg2;
      uint16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"fmx\", fnname = \"vpmax_u16\", rettype = \"uint16x4_t\", argtypes = \"[uint16x4_t,uint16x4_t]\", vals = [VectorVal [IntegerVal 61609,IntegerVal 45195,IntegerVal 0,IntegerVal 32768],VectorVal [IntegerVal 0,IntegerVal 0,IntegerVal 0,IntegerVal 0]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u16(UINT64_C(0x80000000b08bf0a9));
      arg2 = vcreate_u16(0);
      clear_neon_saturated();
      //  Expect: "result" = 000000008000f0a9
      result = vpmax_u16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u16(result), 0);
      exp = UINT64_C(0x000000008000f0a9);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_783() {

{
   {
      uint32x2_t arg1;
      uint32x2_t arg2;
      uint32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"fmx\", fnname = \"vpmax_u32\", rettype = \"uint32x2_t\", argtypes = \"[uint32x2_t,uint32x2_t]\", vals = [VectorVal [IntegerVal 2147450880,IntegerVal 4294901760],VectorVal [IntegerVal 2909470720,IntegerVal 4294923513]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u32(UINT64_C(0xffff00007fff8000));
      arg2 = vcreate_u32(UINT64_C(0xffff54f9ad6b0000));
      clear_neon_saturated();
      //  Expect: "result" = ffff54f9ffff0000
      result = vpmax_u32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u32(result), 0);
      exp = UINT64_C(0xffff54f9ffff0000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_784() {

{
   {
      float32x2_t arg1;
      float32x2_t arg2;
      float32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"fmx\", fnname = \"vpmax_f32\", rettype = \"float32x2_t\", argtypes = \"[float32x2_t,float32x2_t]\", vals = [VectorVal [FloatVal 0.5732558965682983,FloatVal 0.7369703650474548],VectorVal [FloatVal 0.2440447211265564,FloatVal 0.2410271167755127]], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_f32(UINT64_C(0x3f3caa173f12c0e6));
      arg2 = vcreate_f32(UINT64_C(0x3e76cfd03e79e6dc));
      clear_neon_saturated();
      //  Expect: "result" = 3e79e6dc3f3caa17
      result = vpmax_f32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result, 0);
         exp = ((float32_t) 0.7369703650474548);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result, 1);
         exp = ((float32_t) 0.2440447211265564);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
   }
}
}
void dotests_785() {

{
   {
      int8x16_t arg1;
      int8x16_t arg2;
      int8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"fmx\", fnname = \"vpmaxq_s8\", rettype = \"int8x16_t\", argtypes = \"[int8x16_t,int8x16_t]\", vals = [VectorVal [IntegerVal 127,IntegerVal 127,IntegerVal 127,IntegerVal 127,IntegerVal 0,IntegerVal 127,IntegerVal (-128),IntegerVal (-128),IntegerVal (-128),IntegerVal 127,IntegerVal (-128),IntegerVal (-1),IntegerVal 127,IntegerVal 33,IntegerVal (-128),IntegerVal (-1)],VectorVal [IntegerVal 127,IntegerVal 79,IntegerVal (-51),IntegerVal 0,IntegerVal 99,IntegerVal 0,IntegerVal (-128),IntegerVal (-128),IntegerVal (-128),IntegerVal 0,IntegerVal 0,IntegerVal (-1),IntegerVal 127,IntegerVal (-128),IntegerVal 0,IntegerVal (-116)]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s8(vcreate_s8(UINT64_C(0x80807f007f7f7f7f)),
                         vcreate_s8(UINT64_C(0xff80217fff807f80)));
      arg2 = vcombine_s8(vcreate_s8(UINT64_C(0x8080006300cd4f7f)),
                         vcreate_s8(UINT64_C(0x8c00807fff000080)));
      clear_neon_saturated();
      //  Expect: "result" = 007f00008063007fff7fff7f807f7f7f
      result = vpmaxq_s8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result), 0);
         exp = UINT64_C(0xff7fff7f807f7f7f);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result), 1);
         exp = UINT64_C(0x007f00008063007f);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_786() {

{
   {
      int16x8_t arg1;
      int16x8_t arg2;
      int16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"fmx\", fnname = \"vpmaxq_s16\", rettype = \"int16x8_t\", argtypes = \"[int16x8_t,int16x8_t]\", vals = [VectorVal [IntegerVal 0,IntegerVal (-32768),IntegerVal (-32768),IntegerVal (-16351),IntegerVal (-1),IntegerVal (-1),IntegerVal (-1),IntegerVal 0],VectorVal [IntegerVal (-1),IntegerVal 0,IntegerVal (-1),IntegerVal (-10479),IntegerVal 0,IntegerVal 32767,IntegerVal (-32768),IntegerVal 32767]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s16(vcreate_s16(UINT64_C(0xc021800080000000)),
                          vcreate_s16(UINT64_C(0x0000ffffffffffff)));
      arg2 = vcombine_s16(vcreate_s16(UINT64_C(0xd711ffff0000ffff)),
                          vcreate_s16(UINT64_C(0x7fff80007fff0000)));
      clear_neon_saturated();
      //  Expect: "result" = 7fff7fffffff00000000ffffc0210000
      result = vpmaxq_s16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 0);
         exp = UINT64_C(0x0000ffffc0210000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 1);
         exp = UINT64_C(0x7fff7fffffff0000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_787() {

{
   {
      int32x4_t arg1;
      int32x4_t arg2;
      int32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"fmx\", fnname = \"vpmaxq_s32\", rettype = \"int32x4_t\", argtypes = \"[int32x4_t,int32x4_t]\", vals = [VectorVal [IntegerVal (-2147450880),IntegerVal 2147450880,IntegerVal 34207,IntegerVal 375973349],VectorVal [IntegerVal (-32768),IntegerVal (-1608056833),IntegerVal (-65536),IntegerVal 2147450880]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s32(vcreate_s32(UINT64_C(0x7fff800080008000)),
                          vcreate_s32(UINT64_C(0x1668e5e50000859f)));
      arg2 = vcombine_s32(vcreate_s32(UINT64_C(0xa026ffffffff8000)),
                          vcreate_s32(UINT64_C(0x7fff8000ffff0000)));
      clear_neon_saturated();
      //  Expect: "result" = 7fff8000ffff80001668e5e57fff8000
      result = vpmaxq_s32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 0);
         exp = UINT64_C(0x1668e5e57fff8000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 1);
         exp = UINT64_C(0x7fff8000ffff8000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_788() {

{
   {
      uint8x16_t arg1;
      uint8x16_t arg2;
      uint8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"fmx\", fnname = \"vpmaxq_u8\", rettype = \"uint8x16_t\", argtypes = \"[uint8x16_t,uint8x16_t]\", vals = [VectorVal [IntegerVal 128,IntegerVal 211,IntegerVal 32,IntegerVal 0,IntegerVal 255,IntegerVal 128,IntegerVal 0,IntegerVal 0,IntegerVal 162,IntegerVal 127,IntegerVal 0,IntegerVal 108,IntegerVal 0,IntegerVal 128,IntegerVal 127,IntegerVal 0],VectorVal [IntegerVal 255,IntegerVal 0,IntegerVal 3,IntegerVal 0,IntegerVal 255,IntegerVal 128,IntegerVal 128,IntegerVal 0,IntegerVal 127,IntegerVal 255,IntegerVal 127,IntegerVal 135,IntegerVal 0,IntegerVal 128,IntegerVal 0,IntegerVal 0]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u8(vcreate_u8(UINT64_C(0x000080ff0020d380)),
                         vcreate_u8(UINT64_C(0x007f80006c007fa2)));
      arg2 = vcombine_u8(vcreate_u8(UINT64_C(0x008080ff000300ff)),
                         vcreate_u8(UINT64_C(0x00008000877fff7f)));
      clear_neon_saturated();
      //  Expect: "result" = 008087ff80ff03ff7f806ca200ff20d3
      result = vpmaxq_u8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 0);
         exp = UINT64_C(0x7f806ca200ff20d3);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 1);
         exp = UINT64_C(0x008087ff80ff03ff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_789() {

{
   {
      uint16x8_t arg1;
      uint16x8_t arg2;
      uint16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"fmx\", fnname = \"vpmaxq_u16\", rettype = \"uint16x8_t\", argtypes = \"[uint16x8_t,uint16x8_t]\", vals = [VectorVal [IntegerVal 32768,IntegerVal 0,IntegerVal 32767,IntegerVal 65535,IntegerVal 41287,IntegerVal 32767,IntegerVal 32768,IntegerVal 11730],VectorVal [IntegerVal 45152,IntegerVal 65535,IntegerVal 32767,IntegerVal 61587,IntegerVal 32767,IntegerVal 32767,IntegerVal 62134,IntegerVal 65535]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u16(vcreate_u16(UINT64_C(0xffff7fff00008000)),
                          vcreate_u16(UINT64_C(0x2dd280007fffa147)));
      arg2 = vcombine_u16(vcreate_u16(UINT64_C(0xf0937fffffffb060)),
                          vcreate_u16(UINT64_C(0xfffff2b67fff7fff)));
      clear_neon_saturated();
      //  Expect: "result" = ffff7ffff093ffff8000a147ffff8000
      result = vpmaxq_u16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 0);
         exp = UINT64_C(0x8000a147ffff8000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 1);
         exp = UINT64_C(0xffff7ffff093ffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_790() {

{
   {
      uint32x4_t arg1;
      uint32x4_t arg2;
      uint32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"fmx\", fnname = \"vpmaxq_u32\", rettype = \"uint32x4_t\", argtypes = \"[uint32x4_t,uint32x4_t]\", vals = [VectorVal [IntegerVal 313425920,IntegerVal 32767,IntegerVal 2147450880,IntegerVal 2147524348],VectorVal [IntegerVal 2147498939,IntegerVal 3939074047,IntegerVal 32767,IntegerVal 4294967295]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u32(vcreate_u32(UINT64_C(0x00007fff12ae8000)),
                          vcreate_u32(UINT64_C(0x80009efc7fff8000)));
      arg2 = vcombine_u32(vcreate_u32(UINT64_C(0xeac97fff80003bbb)),
                          vcreate_u32(UINT64_C(0xffffffff00007fff)));
      clear_neon_saturated();
      //  Expect: "result" = ffffffffeac97fff80009efc12ae8000
      result = vpmaxq_u32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 0);
         exp = UINT64_C(0x80009efc12ae8000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 1);
         exp = UINT64_C(0xffffffffeac97fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_791() {

{
   {
      float32x4_t arg1;
      float32x4_t arg2;
      float32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"fmx\", fnname = \"vpmaxq_f32\", rettype = \"float32x4_t\", argtypes = \"[float32x4_t,float32x4_t]\", vals = [VectorVal [FloatVal 0.32884538173675537,FloatVal 0.4253552556037903,FloatVal 0.1875562071800232,FloatVal 0.10170572996139526],VectorVal [FloatVal 6.713569164276123e-3,FloatVal 4.9896240234375e-3,FloatVal 0.12627363204956055,FloatVal 0.48655301332473755]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_f32(vcreate_f32(UINT64_C(0x3ed9c82a3ea85e6c)),
                          vcreate_f32(UINT64_C(0x3dd04b183e400ebc)));
      arg2 = vcombine_f32(vcreate_f32(UINT64_C(0x3ba380003bdbfd80)),
                          vcreate_f32(UINT64_C(0x3ef91d7a3e014de0)));
      clear_neon_saturated();
      //  Expect: "result" = 3ef91d7a3bdbfd803e400ebc3ed9c82a
      result = vpmaxq_f32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 0);
         exp = ((float32_t) 0.4253552556037903);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 1);
         exp = ((float32_t) 0.1875562071800232);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 2);
         exp = ((float32_t) 6.713569164276123e-3);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 2 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 3);
         exp = ((float32_t) 0.48655301332473755);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 3 ", exp, got);
            }
      }
   }
}
}
void dotests_792() {

{
   {
      float64x2_t arg1;
      float64x2_t arg2;
      float64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"fmx\", fnname = \"vpmaxq_f64\", rettype = \"float64x2_t\", argtypes = \"[float64x2_t,float64x2_t]\", vals = [VectorVal [FloatVal 0.5701393642543953,FloatVal 0.12256113631528087],VectorVal [FloatVal 0.7625014215406176,FloatVal 0.3093593747615223]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_f64(vcreate_f64(UINT64_C(0x3fe23e94e87450c4)),
                          vcreate_f64(UINT64_C(0x3fbf602aa83c1738)));
      arg2 = vcombine_f64(vcreate_f64(UINT64_C(0x3fe866696195746e)),
                          vcreate_f64(UINT64_C(0x3fd3cc8b4353f3a6)));
      clear_neon_saturated();
      //  Expect: "result" = 3fe866696195746e3fe23e94e87450c4
      result = vpmaxq_f64(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float64_t got;
         float64_t exp;
         got = vgetq_lane_f64(result, 0);
         exp = 0.5701393642543953;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float64_t got;
         float64_t exp;
         got = vgetq_lane_f64(result, 1);
         exp = 0.7625014215406176;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
   }
}
}
void dotests_793() {

{
   {
      float32x2_t arg1;
      float32_t result;
      char* str1 = "ReproInfo2 {semantics = \"fmx\", fnname = \"vpmaxs_f32\", rettype = \"float32_t\", argtypes = \"[float32x2_t]\", vals = [VectorVal [FloatVal 4.704582691192627e-2,FloatVal 0.1575869917869568]], start_saturated = False}";
      int reported = 0;
      float32_t got;
      float32_t exp;
      arg1 = vcreate_f32(UINT64_C(0x3e215e7c3d40b320));
      clear_neon_saturated();
      //  Expect: "result" = 3e215e7c
      result = vpmaxs_f32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = ((float32_t) 0.1575869917869568);
      if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %f Got: %f\n", "   ", exp, got);
         }
   }
}
}
void dotests_794() {

{
   {
      float64x2_t arg1;
      float64_t result;
      char* str1 = "ReproInfo2 {semantics = \"fmx\", fnname = \"vpmaxqd_f64\", rettype = \"float64_t\", argtypes = \"[float64x2_t]\", vals = [VectorVal [FloatVal 0.4379303619632753,FloatVal 0.3559260097340863]], start_saturated = False}";
      int reported = 0;
      float64_t got;
      float64_t exp;
      arg1 = vcombine_f64(vcreate_f64(UINT64_C(0x3fdc070d11a3b184)),
                          vcreate_f64(UINT64_C(0x3fd6c77de2e6a2aa)));
      clear_neon_saturated();
      //  Expect: "result" = 3fdc070d11a3b184
      result = vpmaxqd_f64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = 0.4379303619632753;
      if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %f Got: %f\n", "   ", exp, got);
         }
   }
}
}
void dotests_795() {

{
   {
      float32x2_t arg1;
      float32x2_t arg2;
      float32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"fmxnm\", fnname = \"vpmaxnm_f32\", rettype = \"float32x2_t\", argtypes = \"[float32x2_t,float32x2_t]\", vals = [VectorVal [FloatVal 0.40141749382019043,FloatVal 0.2708399295806885],VectorVal [FloatVal 0.7598331570625305,FloatVal 0.5469751954078674]], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_f32(UINT64_C(0x3e8aab883ecd8698));
      arg2 = vcreate_f32(UINT64_C(0x3f0c06913f42846d));
      clear_neon_saturated();
      //  Expect: "result" = 3f42846d3ecd8698
      result = vpmaxnm_f32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result, 0);
         exp = ((float32_t) 0.40141749382019043);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result, 1);
         exp = ((float32_t) 0.7598331570625305);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
   }
}
}
void dotests_796() {

{
   {
      float32x4_t arg1;
      float32x4_t arg2;
      float32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"fmxnm\", fnname = \"vpmaxnmq_f32\", rettype = \"float32x4_t\", argtypes = \"[float32x4_t,float32x4_t]\", vals = [VectorVal [FloatVal 0.5689829587936401,FloatVal 5.279207229614258e-2,FloatVal 0.9570112228393555,FloatVal 6.763666868209839e-2],VectorVal [FloatVal 0.9299212098121643,FloatVal 0.9887785911560059,FloatVal 0.5643205046653748,FloatVal 0.34595829248428345]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_f32(vcreate_f32(UINT64_C(0x3d583c803f11a8de)),
                          vcreate_f32(UINT64_C(0x3d8a85183f74feb0)));
      arg2 = vcombine_f32(vcreate_f32(UINT64_C(0x3f7d20983f6e0f51)),
                          vcreate_f32(UINT64_C(0x3eb121723f10774f)));
      clear_neon_saturated();
      //  Expect: "result" = 3f10774f3f7d20983f74feb03f11a8de
      result = vpmaxnmq_f32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 0);
         exp = ((float32_t) 0.5689829587936401);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 1);
         exp = ((float32_t) 0.9570112228393555);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 2);
         exp = ((float32_t) 0.9887785911560059);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 2 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 3);
         exp = ((float32_t) 0.5643205046653748);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 3 ", exp, got);
            }
      }
   }
}
}
void dotests_797() {

{
   {
      float64x2_t arg1;
      float64x2_t arg2;
      float64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"fmxnm\", fnname = \"vpmaxnmq_f64\", rettype = \"float64x2_t\", argtypes = \"[float64x2_t,float64x2_t]\", vals = [VectorVal [FloatVal 0.7036092428640275,FloatVal 0.6987858126312604],VectorVal [FloatVal 8.426034187112064e-2,FloatVal 0.13360052205764983]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_f64(vcreate_f64(UINT64_C(0x3fe683f787e8754e)),
                          vcreate_f64(UINT64_C(0x3fe65c7410851f1b)));
      arg2 = vcombine_f64(vcreate_f64(UINT64_C(0x3fb59215f4afad98)),
                          vcreate_f64(UINT64_C(0x3fc119d2687baa3c)));
      clear_neon_saturated();
      //  Expect: "result" = 3fc119d2687baa3c3fe683f787e8754e
      result = vpmaxnmq_f64(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float64_t got;
         float64_t exp;
         got = vgetq_lane_f64(result, 0);
         exp = 0.7036092428640275;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float64_t got;
         float64_t exp;
         got = vgetq_lane_f64(result, 1);
         exp = 0.13360052205764983;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
   }
}
}
void dotests_798() {

{
   {
      float32x2_t arg1;
      float32_t result;
      char* str1 = "ReproInfo2 {semantics = \"fmxnm\", fnname = \"vpmaxnms_f32\", rettype = \"float32_t\", argtypes = \"[float32x2_t]\", vals = [VectorVal [FloatVal 0.9798774123191833,FloatVal 0.7207176089286804]], start_saturated = False}";
      int reported = 0;
      float32_t got;
      float32_t exp;
      arg1 = vcreate_f32(UINT64_C(0x3f3880f33f7ad93f));
      clear_neon_saturated();
      //  Expect: "result" = 3f7ad93f
      result = vpmaxnms_f32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = ((float32_t) 0.9798774123191833);
      if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %f Got: %f\n", "   ", exp, got);
         }
   }
}
}
void dotests_799() {

{
   {
      float64x2_t arg1;
      float64_t result;
      char* str1 = "ReproInfo2 {semantics = \"fmxnm\", fnname = \"vpmaxnmqd_f64\", rettype = \"float64_t\", argtypes = \"[float64x2_t]\", vals = [VectorVal [FloatVal 0.5065561443548479,FloatVal 0.702287879519795]], start_saturated = False}";
      int reported = 0;
      float64_t got;
      float64_t exp;
      arg1 = vcombine_f64(vcreate_f64(UINT64_C(0x3fe035b53b32f110)),
                          vcreate_f64(UINT64_C(0x3fe679246e5d4549)));
      clear_neon_saturated();
      //  Expect: "result" = 3fe679246e5d4549
      result = vpmaxnmqd_f64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = 0.702287879519795;
      if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %f Got: %f\n", "   ", exp, got);
         }
   }
}
}
void dotests_800() {

{
   {
      int8x8_t arg1;
      int8x8_t arg2;
      int8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"fmn\", fnname = \"vpmin_s8\", rettype = \"int8x8_t\", argtypes = \"[int8x8_t,int8x8_t]\", vals = [VectorVal [IntegerVal (-128),IntegerVal 0,IntegerVal 127,IntegerVal 127,IntegerVal (-128),IntegerVal 0,IntegerVal (-53),IntegerVal (-128)],VectorVal [IntegerVal (-128),IntegerVal (-1),IntegerVal 0,IntegerVal (-128),IntegerVal 0,IntegerVal (-1),IntegerVal 127,IntegerVal (-128)]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s8(UINT64_C(0x80cb00807f7f0080));
      arg2 = vcreate_s8(UINT64_C(0x807fff008000ff80));
      clear_neon_saturated();
      //  Expect: "result" = 80ff808080807f80
      result = vpmin_s8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s8(result), 0);
      exp = UINT64_C(0x80ff808080807f80);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_801() {

{
   {
      int16x4_t arg1;
      int16x4_t arg2;
      int16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"fmn\", fnname = \"vpmin_s16\", rettype = \"int16x4_t\", argtypes = \"[int16x4_t,int16x4_t]\", vals = [VectorVal [IntegerVal 32767,IntegerVal (-32768),IntegerVal (-1956),IntegerVal 0],VectorVal [IntegerVal (-32768),IntegerVal 32767,IntegerVal 24141,IntegerVal (-1)]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s16(UINT64_C(0x0000f85c80007fff));
      arg2 = vcreate_s16(UINT64_C(0xffff5e4d7fff8000));
      clear_neon_saturated();
      //  Expect: "result" = ffff8000f85c8000
      result = vpmin_s16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s16(result), 0);
      exp = UINT64_C(0xffff8000f85c8000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_802() {

{
   {
      int32x2_t arg1;
      int32x2_t arg2;
      int32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"fmn\", fnname = \"vpmin_s32\", rettype = \"int32x2_t\", argtypes = \"[int32x2_t,int32x2_t]\", vals = [VectorVal [IntegerVal 2147446228,IntegerVal (-32124)],VectorVal [IntegerVal (-2147418113),IntegerVal (-32768)]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s32(UINT64_C(0xffff82847fff6dd4));
      arg2 = vcreate_s32(UINT64_C(0xffff80008000ffff));
      clear_neon_saturated();
      //  Expect: "result" = 8000ffffffff8284
      result = vpmin_s32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s32(result), 0);
      exp = UINT64_C(0x8000ffffffff8284);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_803() {

{
   {
      uint8x8_t arg1;
      uint8x8_t arg2;
      uint8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"fmn\", fnname = \"vpmin_u8\", rettype = \"uint8x8_t\", argtypes = \"[uint8x8_t,uint8x8_t]\", vals = [VectorVal [IntegerVal 127,IntegerVal 255,IntegerVal 127,IntegerVal 65,IntegerVal 128,IntegerVal 200,IntegerVal 128,IntegerVal 128],VectorVal [IntegerVal 189,IntegerVal 128,IntegerVal 255,IntegerVal 82,IntegerVal 255,IntegerVal 127,IntegerVal 0,IntegerVal 0]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u8(UINT64_C(0x8080c880417fff7f));
      arg2 = vcreate_u8(UINT64_C(0x00007fff52ff80bd));
      clear_neon_saturated();
      //  Expect: "result" = 007f52808080417f
      result = vpmin_u8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u8(result), 0);
      exp = UINT64_C(0x007f52808080417f);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_804() {

{
   {
      uint16x4_t arg1;
      uint16x4_t arg2;
      uint16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"fmn\", fnname = \"vpmin_u16\", rettype = \"uint16x4_t\", argtypes = \"[uint16x4_t,uint16x4_t]\", vals = [VectorVal [IntegerVal 32767,IntegerVal 0,IntegerVal 31225,IntegerVal 65535],VectorVal [IntegerVal 32767,IntegerVal 65535,IntegerVal 0,IntegerVal 32767]], start_saturated = True}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u16(UINT64_C(0xffff79f900007fff));
      arg2 = vcreate_u16(UINT64_C(0x7fff0000ffff7fff));
      set_neon_saturated();
      //  Expect: "result" = 00007fff79f90000
      result = vpmin_u16(arg1, arg2);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u16(result), 0);
      exp = UINT64_C(0x00007fff79f90000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_805() {

{
   {
      uint32x2_t arg1;
      uint32x2_t arg2;
      uint32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"fmn\", fnname = \"vpmin_u32\", rettype = \"uint32x2_t\", argtypes = \"[uint32x2_t,uint32x2_t]\", vals = [VectorVal [IntegerVal 3312451584,IntegerVal 2566160383],VectorVal [IntegerVal 2147450879,IntegerVal 3269732885]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u32(UINT64_C(0x98f47fffc5700000));
      arg2 = vcreate_u32(UINT64_C(0xc2e42a157fff7fff));
      clear_neon_saturated();
      //  Expect: "result" = 7fff7fff98f47fff
      result = vpmin_u32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u32(result), 0);
      exp = UINT64_C(0x7fff7fff98f47fff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_806() {

{
   {
      float32x2_t arg1;
      float32x2_t arg2;
      float32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"fmn\", fnname = \"vpmin_f32\", rettype = \"float32x2_t\", argtypes = \"[float32x2_t,float32x2_t]\", vals = [VectorVal [FloatVal 0.47586190700531006,FloatVal 0.6439661383628845],VectorVal [FloatVal 0.13451498746871948,FloatVal 0.7657662630081177]], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_f32(UINT64_C(0x3f24daf73ef3a42c));
      arg2 = vcreate_f32(UINT64_C(0x3f4409423e09be4c));
      clear_neon_saturated();
      //  Expect: "result" = 3e09be4c3ef3a42c
      result = vpmin_f32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result, 0);
         exp = ((float32_t) 0.47586190700531006);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result, 1);
         exp = ((float32_t) 0.13451498746871948);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
   }
}
}
void dotests_807() {

{
   {
      int8x16_t arg1;
      int8x16_t arg2;
      int8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"fmn\", fnname = \"vpminq_s8\", rettype = \"int8x16_t\", argtypes = \"[int8x16_t,int8x16_t]\", vals = [VectorVal [IntegerVal 127,IntegerVal 0,IntegerVal (-88),IntegerVal 111,IntegerVal 127,IntegerVal 0,IntegerVal 127,IntegerVal (-128),IntegerVal (-42),IntegerVal (-128),IntegerVal (-16),IntegerVal 0,IntegerVal 0,IntegerVal 0,IntegerVal (-128),IntegerVal (-63)],VectorVal [IntegerVal 127,IntegerVal (-1),IntegerVal 0,IntegerVal 0,IntegerVal (-1),IntegerVal (-1),IntegerVal 127,IntegerVal 121,IntegerVal 73,IntegerVal 0,IntegerVal (-1),IntegerVal (-77),IntegerVal 0,IntegerVal 0,IntegerVal 0,IntegerVal (-128)]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s8(vcreate_s8(UINT64_C(0x807f007f6fa8007f)),
                         vcreate_s8(UINT64_C(0xc180000000f080d6)));
      arg2 = vcombine_s8(vcreate_s8(UINT64_C(0x797fffff0000ff7f)),
                         vcreate_s8(UINT64_C(0x80000000b3ff0049)));
      clear_neon_saturated();
      //  Expect: "result" = 8000b30079ff00ff8000f0808000a800
      result = vpminq_s8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result), 0);
         exp = UINT64_C(0x8000f0808000a800);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result), 1);
         exp = UINT64_C(0x8000b30079ff00ff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_808() {

{
   {
      int16x8_t arg1;
      int16x8_t arg2;
      int16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"fmn\", fnname = \"vpminq_s16\", rettype = \"int16x8_t\", argtypes = \"[int16x8_t,int16x8_t]\", vals = [VectorVal [IntegerVal (-1),IntegerVal 32767,IntegerVal 0,IntegerVal (-32768),IntegerVal (-1),IntegerVal (-90),IntegerVal (-15325),IntegerVal 32767],VectorVal [IntegerVal (-32768),IntegerVal 22225,IntegerVal (-4463),IntegerVal 0,IntegerVal (-32768),IntegerVal (-1),IntegerVal 32767,IntegerVal 32767]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s16(vcreate_s16(UINT64_C(0x800000007fffffff)),
                          vcreate_s16(UINT64_C(0x7fffc423ffa6ffff)));
      arg2 = vcombine_s16(vcreate_s16(UINT64_C(0x0000ee9156d18000)),
                          vcreate_s16(UINT64_C(0x7fff7fffffff8000)));
      clear_neon_saturated();
      //  Expect: "result" = 7fff8000ee918000c423ffa68000ffff
      result = vpminq_s16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 0);
         exp = UINT64_C(0xc423ffa68000ffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 1);
         exp = UINT64_C(0x7fff8000ee918000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_809() {

{
   {
      int32x4_t arg1;
      int32x4_t arg2;
      int32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"fmn\", fnname = \"vpminq_s32\", rettype = \"int32x4_t\", argtypes = \"[int32x4_t,int32x4_t]\", vals = [VectorVal [IntegerVal (-1022885889),IntegerVal (-1),IntegerVal (-2147418113),IntegerVal (-1)],VectorVal [IntegerVal (-32768),IntegerVal (-12665),IntegerVal 65535,IntegerVal (-65536)]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s32(vcreate_s32(UINT64_C(0xffffffffc307ffff)),
                          vcreate_s32(UINT64_C(0xffffffff8000ffff)));
      arg2 = vcombine_s32(vcreate_s32(UINT64_C(0xffffce87ffff8000)),
                          vcreate_s32(UINT64_C(0xffff00000000ffff)));
      clear_neon_saturated();
      //  Expect: "result" = ffff0000ffff80008000ffffc307ffff
      result = vpminq_s32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 0);
         exp = UINT64_C(0x8000ffffc307ffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 1);
         exp = UINT64_C(0xffff0000ffff8000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_810() {

{
   {
      uint8x16_t arg1;
      uint8x16_t arg2;
      uint8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"fmn\", fnname = \"vpminq_u8\", rettype = \"uint8x16_t\", argtypes = \"[uint8x16_t,uint8x16_t]\", vals = [VectorVal [IntegerVal 255,IntegerVal 255,IntegerVal 128,IntegerVal 175,IntegerVal 127,IntegerVal 0,IntegerVal 0,IntegerVal 128,IntegerVal 127,IntegerVal 255,IntegerVal 255,IntegerVal 127,IntegerVal 255,IntegerVal 128,IntegerVal 127,IntegerVal 3],VectorVal [IntegerVal 198,IntegerVal 89,IntegerVal 127,IntegerVal 111,IntegerVal 255,IntegerVal 0,IntegerVal 255,IntegerVal 134,IntegerVal 127,IntegerVal 127,IntegerVal 128,IntegerVal 0,IntegerVal 255,IntegerVal 128,IntegerVal 255,IntegerVal 0]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u8(vcreate_u8(UINT64_C(0x8000007faf80ffff)),
                         vcreate_u8(UINT64_C(0x037f80ff7fffff7f)));
      arg2 = vcombine_u8(vcreate_u8(UINT64_C(0x86ff00ff6f7f59c6)),
                         vcreate_u8(UINT64_C(0x00ff80ff00807f7f)));
      clear_neon_saturated();
      //  Expect: "result" = 0080007f86006f5903807f7f000080ff
      result = vpminq_u8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 0);
         exp = UINT64_C(0x03807f7f000080ff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 1);
         exp = UINT64_C(0x0080007f86006f59);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_811() {

{
   {
      uint16x8_t arg1;
      uint16x8_t arg2;
      uint16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"fmn\", fnname = \"vpminq_u16\", rettype = \"uint16x8_t\", argtypes = \"[uint16x8_t,uint16x8_t]\", vals = [VectorVal [IntegerVal 65535,IntegerVal 0,IntegerVal 65535,IntegerVal 32767,IntegerVal 32768,IntegerVal 0,IntegerVal 0,IntegerVal 32767],VectorVal [IntegerVal 18193,IntegerVal 47020,IntegerVal 32767,IntegerVal 65535,IntegerVal 32768,IntegerVal 32767,IntegerVal 32767,IntegerVal 57192]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u16(vcreate_u16(UINT64_C(0x7fffffff0000ffff)),
                          vcreate_u16(UINT64_C(0x7fff000000008000)));
      arg2 = vcombine_u16(vcreate_u16(UINT64_C(0xffff7fffb7ac4711)),
                          vcreate_u16(UINT64_C(0xdf687fff7fff8000)));
      clear_neon_saturated();
      //  Expect: "result" = 7fff7fff7fff4711000000007fff0000
      result = vpminq_u16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 0);
         exp = UINT64_C(0x000000007fff0000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 1);
         exp = UINT64_C(0x7fff7fff7fff4711);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_812() {

{
   {
      uint32x4_t arg1;
      uint32x4_t arg2;
      uint32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"fmn\", fnname = \"vpminq_u32\", rettype = \"uint32x4_t\", argtypes = \"[uint32x4_t,uint32x4_t]\", vals = [VectorVal [IntegerVal 4294944979,IntegerVal 1463091200,IntegerVal 2914418687,IntegerVal 4294934528],VectorVal [IntegerVal 2147464978,IntegerVal 2147483648,IntegerVal 2147477085,IntegerVal 2147483648]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u32(vcreate_u32(UINT64_C(0x57350000ffffa8d3)),
                          vcreate_u32(UINT64_C(0xffff8000adb67fff)));
      arg2 = vcombine_u32(vcreate_u32(UINT64_C(0x800000007fffb712)),
                          vcreate_u32(UINT64_C(0x800000007fffe65d)));
      clear_neon_saturated();
      //  Expect: "result" = 7fffe65d7fffb712adb67fff57350000
      result = vpminq_u32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 0);
         exp = UINT64_C(0xadb67fff57350000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 1);
         exp = UINT64_C(0x7fffe65d7fffb712);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_813() {

{
   {
      float32x4_t arg1;
      float32x4_t arg2;
      float32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"fmn\", fnname = \"vpminq_f32\", rettype = \"float32x4_t\", argtypes = \"[float32x4_t,float32x4_t]\", vals = [VectorVal [FloatVal 0.9093769192695618,FloatVal 0.8665168285369873,FloatVal 0.8794846534729004,FloatVal 0.5756726264953613],VectorVal [FloatVal 3.367304801940918e-2,FloatVal 0.9087284803390503,FloatVal 0.27759116888046265,FloatVal 0.631828248500824]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_f32(vcreate_f32(UINT64_C(0x3f5dd40c3f68cced)),
                          vcreate_f32(UINT64_C(0x3f135f483f6125e8)));
      arg2 = vcombine_f32(vcreate_f32(UINT64_C(0x3f68a26e3d09ecc0)),
                          vcreate_f32(UINT64_C(0x3f21bf7f3e8e206e)));
      clear_neon_saturated();
      //  Expect: "result" = 3e8e206e3d09ecc03f135f483f5dd40c
      result = vpminq_f32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 0);
         exp = ((float32_t) 0.8665168285369873);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 1);
         exp = ((float32_t) 0.5756726264953613);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 2);
         exp = ((float32_t) 3.367304801940918e-2);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 2 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 3);
         exp = ((float32_t) 0.27759116888046265);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 3 ", exp, got);
            }
      }
   }
}
}
void dotests_814() {

{
   {
      float64x2_t arg1;
      float64x2_t arg2;
      float64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"fmn\", fnname = \"vpminq_f64\", rettype = \"float64x2_t\", argtypes = \"[float64x2_t,float64x2_t]\", vals = [VectorVal [FloatVal 0.5592863665700314,FloatVal 0.4241495488457946],VectorVal [FloatVal 0.44646026255311877,FloatVal 0.11329716194109785]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_f64(vcreate_f64(UINT64_C(0x3fe1e5ac85b08ae0)),
                          vcreate_f64(UINT64_C(0x3fdb25442639f952)));
      arg2 = vcombine_f64(vcreate_f64(UINT64_C(0x3fdc92ce10a8451e)),
                          vcreate_f64(UINT64_C(0x3fbd010af54441f0)));
      clear_neon_saturated();
      //  Expect: "result" = 3fbd010af54441f03fdb25442639f952
      result = vpminq_f64(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float64_t got;
         float64_t exp;
         got = vgetq_lane_f64(result, 0);
         exp = 0.4241495488457946;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float64_t got;
         float64_t exp;
         got = vgetq_lane_f64(result, 1);
         exp = 0.11329716194109785;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
   }
}
}
void dotests_815() {

{
   {
      float32x2_t arg1;
      float32_t result;
      char* str1 = "ReproInfo2 {semantics = \"fmn\", fnname = \"vpmins_f32\", rettype = \"float32_t\", argtypes = \"[float32x2_t]\", vals = [VectorVal [FloatVal 0.22330915927886963,FloatVal 0.9844769239425659]], start_saturated = False}";
      int reported = 0;
      float32_t got;
      float32_t exp;
      arg1 = vcreate_f32(UINT64_C(0x3f7c06ae3e64ab28));
      clear_neon_saturated();
      //  Expect: "result" = 3e64ab28
      result = vpmins_f32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = ((float32_t) 0.22330915927886963);
      if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %f Got: %f\n", "   ", exp, got);
         }
   }
}
}
void dotests_816() {

{
   {
      float64x2_t arg1;
      float64_t result;
      char* str1 = "ReproInfo2 {semantics = \"fmn\", fnname = \"vpminqd_f64\", rettype = \"float64_t\", argtypes = \"[float64x2_t]\", vals = [VectorVal [FloatVal 0.16356383098462002,FloatVal 0.9054754132993077]], start_saturated = False}";
      int reported = 0;
      float64_t got;
      float64_t exp;
      arg1 = vcombine_f64(vcreate_f64(UINT64_C(0x3fc4efa8dc7196cc)),
                          vcreate_f64(UINT64_C(0x3fecf9a792ee7bc8)));
      clear_neon_saturated();
      //  Expect: "result" = 3fc4efa8dc7196cc
      result = vpminqd_f64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = 0.16356383098462002;
      if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %f Got: %f\n", "   ", exp, got);
         }
   }
}
}
void dotests_817() {

{
   {
      float32x2_t arg1;
      float32x2_t arg2;
      float32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"fmnnm\", fnname = \"vpminnm_f32\", rettype = \"float32x2_t\", argtypes = \"[float32x2_t,float32x2_t]\", vals = [VectorVal [FloatVal 0.27851444482803345,FloatVal 0.9332903623580933],VectorVal [FloatVal 0.9055414199829102,FloatVal 8.372682332992554e-2]], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_f32(UINT64_C(0x3f6eec1e3e8e9972));
      arg2 = vcreate_f32(UINT64_C(0x3dab78f83f67d190));
      clear_neon_saturated();
      //  Expect: "result" = 3dab78f83e8e9972
      result = vpminnm_f32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result, 0);
         exp = ((float32_t) 0.27851444482803345);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result, 1);
         exp = ((float32_t) 8.372682332992554e-2);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
   }
}
}
void dotests_818() {

{
   {
      float32x4_t arg1;
      float32x4_t arg2;
      float32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"fmnnm\", fnname = \"vpminnmq_f32\", rettype = \"float32x4_t\", argtypes = \"[float32x4_t,float32x4_t]\", vals = [VectorVal [FloatVal 0.17567598819732666,FloatVal 0.94499272108078,FloatVal 0.4043561816215515,FloatVal 0.4385790228843689],VectorVal [FloatVal 0.43952351808547974,FloatVal 0.2655491232872009,FloatVal 4.98124361038208e-2,FloatVal 0.11430150270462036]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_f32(vcreate_f32(UINT64_C(0x3f71eb0b3e33e468)),
                          vcreate_f32(UINT64_C(0x3ee08d6e3ecf07c6)));
      arg2 = vcombine_f32(vcreate_f32(UINT64_C(0x3e87f60e3ee1093a)),
                          vcreate_f32(UINT64_C(0x3dea16e83d4c0820)));
      clear_neon_saturated();
      //  Expect: "result" = 3d4c08203e87f60e3ecf07c63e33e468
      result = vpminnmq_f32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 0);
         exp = ((float32_t) 0.17567598819732666);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 1);
         exp = ((float32_t) 0.4043561816215515);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 2);
         exp = ((float32_t) 0.2655491232872009);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 2 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 3);
         exp = ((float32_t) 4.98124361038208e-2);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 3 ", exp, got);
            }
      }
   }
}
}
void dotests_819() {

{
   {
      float64x2_t arg1;
      float64x2_t arg2;
      float64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"fmnnm\", fnname = \"vpminnmq_f64\", rettype = \"float64x2_t\", argtypes = \"[float64x2_t,float64x2_t]\", vals = [VectorVal [FloatVal 0.39168725870856425,FloatVal 0.6681787778634004],VectorVal [FloatVal 3.2034908784545735e-2,FloatVal 0.41924994780548297]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_f64(vcreate_f64(UINT64_C(0x3fd911676f9a7174)),
                          vcreate_f64(UINT64_C(0x3fe561b875d9bee7)));
      arg2 = vcombine_f64(vcreate_f64(UINT64_C(0x3fa066e12b1eb400)),
                          vcreate_f64(UINT64_C(0x3fdad4fdbbab2704)));
      clear_neon_saturated();
      //  Expect: "result" = 3fa066e12b1eb4003fd911676f9a7174
      result = vpminnmq_f64(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float64_t got;
         float64_t exp;
         got = vgetq_lane_f64(result, 0);
         exp = 0.39168725870856425;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float64_t got;
         float64_t exp;
         got = vgetq_lane_f64(result, 1);
         exp = 3.2034908784545735e-2;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
   }
}
}
void dotests_820() {

{
   {
      float32x2_t arg1;
      float32_t result;
      char* str1 = "ReproInfo2 {semantics = \"fmnnm\", fnname = \"vpminnms_f32\", rettype = \"float32_t\", argtypes = \"[float32x2_t]\", vals = [VectorVal [FloatVal 0.8494278192520142,FloatVal 0.5204430818557739]], start_saturated = False}";
      int reported = 0;
      float32_t got;
      float32_t exp;
      arg1 = vcreate_f32(UINT64_C(0x3f053bc23f59741a));
      clear_neon_saturated();
      //  Expect: "result" = 3f053bc2
      result = vpminnms_f32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = ((float32_t) 0.5204430818557739);
      if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %f Got: %f\n", "   ", exp, got);
         }
   }
}
}
void dotests_821() {

{
   {
      float64x2_t arg1;
      float64_t result;
      char* str1 = "ReproInfo2 {semantics = \"fmnnm\", fnname = \"vpminnmqd_f64\", rettype = \"float64_t\", argtypes = \"[float64x2_t]\", vals = [VectorVal [FloatVal 0.9208322854005346,FloatVal 0.3882457635678611]], start_saturated = False}";
      int reported = 0;
      float64_t got;
      float64_t exp;
      arg1 = vcombine_f64(vcreate_f64(UINT64_C(0x3fed777544dcadf4)),
                          vcreate_f64(UINT64_C(0x3fd8d904c25568a4)));
      clear_neon_saturated();
      //  Expect: "result" = 3fd8d904c25568a4
      result = vpminnmqd_f64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = 0.3882457635678611;
      if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %f Got: %f\n", "   ", exp, got);
         }
   }
}
}
void dotests_822() {

{
   {
      float32x2_t arg1;
      float32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"sqrt\", fnname = \"vsqrt_f32\", rettype = \"float32x2_t\", argtypes = \"[float32x2_t]\", vals = [VectorVal [FloatVal 0.7235091924667358,FloatVal 0.36142611503601074]], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_f32(UINT64_C(0x3eb90cd83f3937e6));
      clear_neon_saturated();
      //  Expect: "result" = 3f19e7683f59c07d
      result = vsqrt_f32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result, 0);
         exp = ((float32_t) 0.850593435471222);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result, 1);
         exp = ((float32_t) 0.6011872545521992);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
   }
}
}
void dotests_823() {

{
   {
      float64x1_t arg1;
      float64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"sqrt\", fnname = \"vsqrt_f64\", rettype = \"float64x1_t\", argtypes = \"[float64x1_t]\", vals = [VectorVal [FloatVal 0.8910375154407275]], start_saturated = False}";
      int reported = 0;
      float64_t got;
      float64_t exp;
      arg1 = vcreate_f64(UINT64_C(0x3fec83611b8a76f2));
      clear_neon_saturated();
      //  Expect: "result" = 3fee34d2171fffaa
      result = vsqrt_f64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_f64(result, 0);
      exp = 0.9439478351268822;
      if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
         }
   }
}
}
void dotests_824() {

{
   {
      float32x4_t arg1;
      float32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"sqrt\", fnname = \"vsqrtq_f32\", rettype = \"float32x4_t\", argtypes = \"[float32x4_t]\", vals = [VectorVal [FloatVal 0.48512548208236694,FloatVal 0.7305597066879272,FloatVal 0.2980661392211914,FloatVal 0.7168429493904114]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_f32(vcreate_f32(UINT64_C(0x3f3b05f63ef8625e)),
                          vcreate_f32(UINT64_C(0x3f3783053e989c20)));
      clear_neon_saturated();
      //  Expect: "result" = 3f58bf163f0bc3a93f5acf713f324e72
      result = vsqrtq_f32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 0);
         exp = ((float32_t) 0.6965094989175431);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 1);
         exp = ((float32_t) 0.8547278553363797);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 2);
         exp = ((float32_t) 0.5459543380367917);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 2 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 3);
         exp = ((float32_t) 0.8466657837602812);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 3 ", exp, got);
            }
      }
   }
}
}
void dotests_825() {

{
   {
      float64x2_t arg1;
      float64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"sqrt\", fnname = \"vsqrtq_f64\", rettype = \"float64x2_t\", argtypes = \"[float64x2_t]\", vals = [VectorVal [FloatVal 0.9939169126298991,FloatVal 0.15814637179066215]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_f64(vcreate_f64(UINT64_C(0x3fefce2ad755f97f)),
                          vcreate_f64(UINT64_C(0x3fc43e23eb6935b0)));
      clear_neon_saturated();
      //  Expect: "result" = 3fd97386f0344eb43fefe70bb0caf8a4
      result = vsqrtq_f64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float64_t got;
         float64_t exp;
         got = vgetq_lane_f64(result, 0);
         exp = 0.9969538166985967;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float64_t got;
         float64_t exp;
         got = vgetq_lane_f64(result, 1);
         exp = 0.39767621476606085;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
   }
}
}
void dotests_826() {

{
   {
      float32x2_t arg1;
      float32x2_t arg2;
      float32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"recps\", fnname = \"vrecps_f32\", rettype = \"float32x2_t\", argtypes = \"[float32x2_t,float32x2_t]\", vals = [VectorVal [FloatVal 0.7648143172264099,FloatVal 0.11184453964233398],VectorVal [FloatVal 0.30903148651123047,FloatVal 0.5722271800041199]], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_f32(UINT64_C(0x3de50ec03f43cadf));
      arg2 = vcreate_f32(UINT64_C(0x3f127d7b3e9e3960));
      clear_neon_saturated();
      //  Expect: "result" = 3ff7ced53fe1bf3a
      result = vrecps_f32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result, 0);
         exp = ((float32_t) 1.7636482946424508);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result, 1);
         exp = ((float32_t) 1.9359995144816082);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
   }
}
}
void dotests_827() {

{
   {
      float64x1_t arg1;
      float64x1_t arg2;
      float64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"recps\", fnname = \"vrecps_f64\", rettype = \"float64x1_t\", argtypes = \"[float64x1_t,float64x1_t]\", vals = [VectorVal [FloatVal 0.3501792041229741],VectorVal [FloatVal 0.2667140772520942]], start_saturated = True}";
      int reported = 0;
      float64_t got;
      float64_t exp;
      arg1 = vcreate_f64(UINT64_C(0x3fd66956095ca38c));
      arg2 = vcreate_f64(UINT64_C(0x3fd111d7ebcb8e54));
      set_neon_saturated();
      //  Expect: "result" = 3ffe8171638e7428
      result = vrecps_f64(arg1, arg2);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      got = vget_lane_f64(result, 0);
      exp = 1.9066022766994681;
      if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
         }
   }
}
}
void dotests_828() {

{
   {
      float32x4_t arg1;
      float32x4_t arg2;
      float32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"recps\", fnname = \"vrecpsq_f32\", rettype = \"float32x4_t\", argtypes = \"[float32x4_t,float32x4_t]\", vals = [VectorVal [FloatVal 0.8140439391136169,FloatVal 0.5928670763969421,FloatVal 0.9536811113357544,FloatVal 0.5667416453361511],VectorVal [FloatVal 0.3973742127418518,FloatVal 0.8232712149620056,FloatVal 0.43562185764312744,FloatVal 6.63609504699707e-2]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_f32(vcreate_f32(UINT64_C(0x3f17c6233f50652f)),
                          vcreate_f32(UINT64_C(0x3f1115fb3f742472)));
      arg2 = vcombine_f32(vcreate_f32(UINT64_C(0x3f52c1e73ecb74a2)),
                          vcreate_f32(UINT64_C(0x3d87e8403edf09d4)));
      clear_neon_saturated();
      //  Expect: "result" = 3ffb2f9c3fcad2b83fc186403fd69834
      result = vrecpsq_f32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 0);
         exp = ((float32_t) 1.6765199305574505);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 1);
         exp = ((float32_t) 1.5119096017037172);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 2);
         exp = ((float32_t) 1.5845556626807564);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 2 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 3);
         exp = ((float32_t) 1.962390485744578);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 3 ", exp, got);
            }
      }
   }
}
}
void dotests_829() {

{
   {
      float64x2_t arg1;
      float64x2_t arg2;
      float64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"recps\", fnname = \"vrecpsq_f64\", rettype = \"float64x2_t\", argtypes = \"[float64x2_t,float64x2_t]\", vals = [VectorVal [FloatVal 0.29446363799999753,FloatVal 0.3183084887468238],VectorVal [FloatVal 0.6484501270536956,FloatVal 0.5872190703909317]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_f64(vcreate_f64(UINT64_C(0x3fd2d87e03c48e16)),
                          vcreate_f64(UINT64_C(0x3fd45f2a914d3c16)));
      arg2 = vcombine_f64(vcreate_f64(UINT64_C(0x3fe4c01a7b190b9d)),
                          vcreate_f64(UINT64_C(0x3fe2ca7fa5dd5492)));
      clear_neon_saturated();
      //  Expect: "result" = 3ffd02638391b2db3ffcf1e3ac4a511e
      result = vrecpsq_f64(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float64_t got;
         float64_t exp;
         got = vgetq_lane_f64(result, 0);
         exp = 1.8090550165262083;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float64_t got;
         float64_t exp;
         got = vgetq_lane_f64(result, 1);
         exp = 1.8130831851405478;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
   }
}
}
void dotests_830() {

{
   {
      float32_t arg1;
      float32_t arg2;
      float32_t result;
      char* str1 = "ReproInfo2 {semantics = \"recps\", fnname = \"vrecpss_f32\", rettype = \"float32_t\", argtypes = \"[float32_t,float32_t]\", vals = [FloatVal 0.8399787545204163,FloatVal 0.2942943572998047], start_saturated = False}";
      int reported = 0;
      float32_t got;
      float32_t exp;
      arg1 = ((float32_t) 0.8399787545204163);
      arg2 = ((float32_t) 0.2942943572998047);
      clear_neon_saturated();
      //  Expect: "result" = 3fe05bb7
      result = vrecpss_f32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = ((float32_t) 1.7527989922929237);
      if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %f Got: %f\n", "   ", exp, got);
         }
   }
}
}
void dotests_831() {

{
   {
      float64_t arg1;
      float64_t arg2;
      float64_t result;
      char* str1 = "ReproInfo2 {semantics = \"recps\", fnname = \"vrecpsd_f64\", rettype = \"float64_t\", argtypes = \"[float64_t,float64_t]\", vals = [FloatVal 8.20356905698979e-2,FloatVal 0.2883553744018891], start_saturated = False}";
      int reported = 0;
      float64_t got;
      float64_t exp;
      arg1 = 8.20356905698979e-2;
      arg2 = 0.2883553744018891;
      clear_neon_saturated();
      //  Expect: "result" = 3fff9f1b7b4089b3
      result = vrecpsd_f64(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = 1.9763445677313995;
      if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %f Got: %f\n", "   ", exp, got);
         }
   }
}
}
void dotests_832() {

{
   {
      float32x2_t arg1;
      float32x2_t arg2;
      float32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"rsqrts\", fnname = \"vrsqrts_f32\", rettype = \"float32x2_t\", argtypes = \"[float32x2_t,float32x2_t]\", vals = [VectorVal [FloatVal 2.9486775398254395e-2,FloatVal 0.16001677513122559],VectorVal [FloatVal 0.524165689945221,FloatVal 0.264965295791626]], start_saturated = True}";
      int reported = 0;
      arg1 = vcreate_f32(UINT64_C(0x3e23db703cf18e40));
      arg2 = vcreate_f32(UINT64_C(0x3e87a9883f062fb9));
      set_neon_saturated();
      //  Expect: "result" = 3fbd49563fbf02c5
      result = vrsqrts_f32(arg1, arg2);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result, 0);
         exp = ((float32_t) 1.492272022014557);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result, 1);
         exp = ((float32_t) 1.4788005539228664);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
   }
}
}
void dotests_833() {

{
   {
      float64x1_t arg1;
      float64x1_t arg2;
      float64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"rsqrts\", fnname = \"vrsqrts_f64\", rettype = \"float64x1_t\", argtypes = \"[float64x1_t,float64x1_t]\", vals = [VectorVal [FloatVal 0.8052180028085417],VectorVal [FloatVal 0.8401649252483836]], start_saturated = False}";
      int reported = 0;
      float64_t got;
      float64_t exp;
      arg1 = vcreate_f64(UINT64_C(0x3fe9c4588b86d1e7));
      arg2 = vcreate_f64(UINT64_C(0x3feae2a18da604da));
      clear_neon_saturated();
      //  Expect: "result" = 3ff2967ed1d72eac
      result = vrsqrts_f64(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_f64(result, 0);
      exp = 1.1617420384308543;
      if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
         }
   }
}
}
void dotests_834() {

{
   {
      float32x4_t arg1;
      float32x4_t arg2;
      float32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"rsqrts\", fnname = \"vrsqrtsq_f32\", rettype = \"float32x4_t\", argtypes = \"[float32x4_t,float32x4_t]\", vals = [VectorVal [FloatVal 0.4617043733596802,FloatVal 0.21331703662872314,FloatVal 7.606929540634155e-2,FloatVal 0.8658933043479919],VectorVal [FloatVal 0.11494708061218262,FloatVal 0.9888914227485657,FloatVal 0.44075441360473633,FloatVal 0.32476216554641724]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_f32(vcreate_f32(UINT64_C(0x3e5a6fc83eec6484)),
                          vcreate_f32(UINT64_C(0x3f5dab2f3d9bca38)));
      arg2 = vcombine_f32(vcreate_f32(UINT64_C(0x3f7d27fd3deb6960)),
                          vcreate_f32(UINT64_C(0x3ea6473a3ee1aa90)));
      clear_neon_saturated();
      //  Expect: "result" = 3fae00aa3fbddaad3fb27fd63fbc9a79
      result = vrsqrtsq_f32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 0);
         exp = ((float32_t) 1.4734642150882138);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 1);
         exp = ((float32_t) 1.394526306075857);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 2);
         exp = ((float32_t) 1.4832360611549262);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 2 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 3);
         exp = ((float32_t) 1.3593953076739016);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 3 ", exp, got);
            }
      }
   }
}
}
void dotests_835() {

{
   {
      float64x2_t arg1;
      float64x2_t arg2;
      float64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"rsqrts\", fnname = \"vrsqrtsq_f64\", rettype = \"float64x2_t\", argtypes = \"[float64x2_t,float64x2_t]\", vals = [VectorVal [FloatVal 0.8080320733257208,FloatVal 0.9099133715912304],VectorVal [FloatVal 3.032374690269246e-2,FloatVal 0.7858650065614456]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_f64(vcreate_f64(UINT64_C(0x3fe9db661421b28b)),
                          vcreate_f64(UINT64_C(0x3fed1e02a5a5ad82)));
      arg2 = vcombine_f64(vcreate_f64(UINT64_C(0x3f9f0d3034f4fcc0)),
                          vcreate_f64(UINT64_C(0x3fe925ce5ec8124e)));
      clear_neon_saturated();
      //  Expect: "result" = 3ff24789dd05f2a23ff7cdd19a0e4728
      result = vrsqrtsq_f64(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float64_t got;
         float64_t exp;
         got = vgetq_lane_f64(result, 0);
         exp = 1.4877487199596064;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float64_t got;
         float64_t exp;
         got = vgetq_lane_f64(result, 1);
         exp = 1.1424654611320553;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
   }
}
}
void dotests_836() {

{
   {
      float32_t arg1;
      float32_t arg2;
      float32_t result;
      char* str1 = "ReproInfo2 {semantics = \"rsqrts\", fnname = \"vrsqrtss_f32\", rettype = \"float32_t\", argtypes = \"[float32_t,float32_t]\", vals = [FloatVal 0.9363987445831299,FloatVal 4.621744155883789e-3], start_saturated = False}";
      int reported = 0;
      float32_t got;
      float32_t exp;
      arg1 = ((float32_t) 0.9363987445831299);
      arg2 = ((float32_t) 4.621744155883789e-3);
      clear_neon_saturated();
      //  Expect: "result" = 3fbfb917
      result = vrsqrtss_f32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = ((float32_t) 1.497836102287323);
      if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %f Got: %f\n", "   ", exp, got);
         }
   }
}
}
void dotests_837() {

{
   {
      float64_t arg1;
      float64_t arg2;
      float64_t result;
      char* str1 = "ReproInfo2 {semantics = \"rsqrts\", fnname = \"vrsqrtsd_f64\", rettype = \"float64_t\", argtypes = \"[float64_t,float64_t]\", vals = [FloatVal 0.6896102538742668,FloatVal 0.4004092956120261], start_saturated = False}";
      int reported = 0;
      float64_t got;
      float64_t exp;
      arg1 = 0.6896102538742668;
      arg2 = 0.4004092956120261;
      clear_neon_saturated();
      //  Expect: "result" = 3ff5ca7e43db4f2d
      result = vrsqrtsd_f64(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = 1.3619368219996872;
      if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %f Got: %f\n", "   ", exp, got);
         }
   }
}
}
void dotests_838() {

{
   {
      int8x8_t arg1;
      int8x8_t arg2;
      int8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"shl\", fnname = \"vshl_s8\", rettype = \"int8x8_t\", argtypes = \"[int8x8_t,int8x8_t]\", vals = [VectorVal [IntegerVal (-128),IntegerVal 127,IntegerVal (-106),IntegerVal 0,IntegerVal (-128),IntegerVal (-1),IntegerVal 127,IntegerVal 72],VectorVal [IntegerVal 0,IntegerVal 95,IntegerVal 101,IntegerVal 96,IntegerVal (-128),IntegerVal (-1),IntegerVal (-128),IntegerVal 127]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s8(UINT64_C(0x487fff8000967f80));
      arg2 = vcreate_s8(UINT64_C(0x7f80ff8060655f00));
      clear_neon_saturated();
      //  Expect: "result" = 0000ffff00000080
      result = vshl_s8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s8(result), 0);
      exp = UINT64_C(0x0000ffff00000080);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_839() {

{
   {
      int16x4_t arg1;
      int16x4_t arg2;
      int16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"shl\", fnname = \"vshl_s16\", rettype = \"int16x4_t\", argtypes = \"[int16x4_t,int16x4_t]\", vals = [VectorVal [IntegerVal 0,IntegerVal (-32768),IntegerVal (-1),IntegerVal (-32768)],VectorVal [IntegerVal 0,IntegerVal 13872,IntegerVal (-29778),IntegerVal (-19711)]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s16(UINT64_C(0x8000ffff80000000));
      arg2 = vcreate_s16(UINT64_C(0xb3018bae36300000));
      clear_neon_saturated();
      //  Expect: "result" = 0000ffff00000000
      result = vshl_s16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s16(result), 0);
      exp = UINT64_C(0x0000ffff00000000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_840() {

{
   {
      int32x2_t arg1;
      int32x2_t arg2;
      int32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"shl\", fnname = \"vshl_s32\", rettype = \"int32x2_t\", argtypes = \"[int32x2_t,int32x2_t]\", vals = [VectorVal [IntegerVal 0,IntegerVal 65535],VectorVal [IntegerVal 32767,IntegerVal (-54357)]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s32(UINT64_C(0x0000ffff00000000));
      arg2 = vcreate_s32(UINT64_C(0xffff2bab00007fff));
      clear_neon_saturated();
      //  Expect: "result" = 0000000000000000
      result = vshl_s32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s32(result), 0);
      exp = 0;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_841() {

{
   {
      int64x1_t arg1;
      int64x1_t arg2;
      int64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"shl\", fnname = \"vshl_s64\", rettype = \"int64x1_t\", argtypes = \"[int64x1_t,int64x1_t]\", vals = [VectorVal [IntegerVal (-281474976710656)],VectorVal [IntegerVal (-9223372034707259393)]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s64(UINT64_C(0xffff000000000000));
      arg2 = vcreate_s64(UINT64_C(0x8000000080007fff));
      clear_neon_saturated();
      //  Expect: "result" = ffff800000000000
      result = vshl_s64(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s64(result), 0);
      exp = UINT64_C(0xffff800000000000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_842() {

{
   {
      uint8x8_t arg1;
      int8x8_t arg2;
      uint8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"shl\", fnname = \"vshl_u8\", rettype = \"uint8x8_t\", argtypes = \"[uint8x8_t,int8x8_t]\", vals = [VectorVal [IntegerVal 128,IntegerVal 128,IntegerVal 2,IntegerVal 0,IntegerVal 0,IntegerVal 255,IntegerVal 128,IntegerVal 0],VectorVal [IntegerVal 0,IntegerVal 0,IntegerVal 56,IntegerVal (-1),IntegerVal (-18),IntegerVal 0,IntegerVal 0,IntegerVal (-128)]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u8(UINT64_C(0x0080ff0000028080));
      arg2 = vcreate_s8(UINT64_C(0x800000eeff380000));
      clear_neon_saturated();
      //  Expect: "result" = 0080ff0000008080
      result = vshl_u8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u8(result), 0);
      exp = UINT64_C(0x0080ff0000008080);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_843() {

{
   {
      uint16x4_t arg1;
      int16x4_t arg2;
      uint16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"shl\", fnname = \"vshl_u16\", rettype = \"uint16x4_t\", argtypes = \"[uint16x4_t,int16x4_t]\", vals = [VectorVal [IntegerVal 25480,IntegerVal 34354,IntegerVal 65535,IntegerVal 32767],VectorVal [IntegerVal 32767,IntegerVal 0,IntegerVal (-7233),IntegerVal (-27451)]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u16(UINT64_C(0x7fffffff86326388));
      arg2 = vcreate_s16(UINT64_C(0x94c5e3bf00007fff));
      clear_neon_saturated();
      //  Expect: "result" = 00000000863231c4
      result = vshl_u16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u16(result), 0);
      exp = UINT64_C(0x00000000863231c4);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_844() {

{
   {
      uint32x2_t arg1;
      int32x2_t arg2;
      uint32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"shl\", fnname = \"vshl_u32\", rettype = \"uint32x2_t\", argtypes = \"[uint32x2_t,int32x2_t]\", vals = [VectorVal [IntegerVal 2147418112,IntegerVal 2147450879],VectorVal [IntegerVal (-2147483648),IntegerVal 32767]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u32(UINT64_C(0x7fff7fff7fff0000));
      arg2 = vcreate_s32(UINT64_C(0x00007fff80000000));
      clear_neon_saturated();
      //  Expect: "result" = 3fffbfff7fff0000
      result = vshl_u32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u32(result), 0);
      exp = UINT64_C(0x3fffbfff7fff0000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_845() {

{
   {
      uint64x1_t arg1;
      int64x1_t arg2;
      uint64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"shl\", fnname = \"vshl_u64\", rettype = \"uint64x1_t\", argtypes = \"[uint64x1_t,int64x1_t]\", vals = [VectorVal [IntegerVal 9223512774343131136],VectorVal [IntegerVal 9223157327144714239]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u64(UINT64_C(0x8000800000000000));
      arg2 = vcreate_s64(UINT64_C(0x7fff3cb900007fff));
      clear_neon_saturated();
      //  Expect: "result" = 4000400000000000
      result = vshl_u64(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(result, 0);
      exp = UINT64_C(0x4000400000000000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_846() {

{
   {
      int8x16_t arg1;
      int8x16_t arg2;
      int8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"shl\", fnname = \"vshlq_s8\", rettype = \"int8x16_t\", argtypes = \"[int8x16_t,int8x16_t]\", vals = [VectorVal [IntegerVal 127,IntegerVal 127,IntegerVal 127,IntegerVal (-1),IntegerVal (-1),IntegerVal 0,IntegerVal 127,IntegerVal 127,IntegerVal 108,IntegerVal 55,IntegerVal (-1),IntegerVal (-1),IntegerVal (-1),IntegerVal 127,IntegerVal (-128),IntegerVal 0],VectorVal [IntegerVal (-1),IntegerVal 0,IntegerVal 127,IntegerVal 127,IntegerVal 127,IntegerVal 127,IntegerVal (-23),IntegerVal (-109),IntegerVal (-1),IntegerVal (-2),IntegerVal (-1),IntegerVal (-75),IntegerVal 0,IntegerVal (-70),IntegerVal (-1),IntegerVal (-4)]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s8(vcreate_s8(UINT64_C(0x7f7f00ffff7f7f7f)),
                         vcreate_s8(UINT64_C(0x00807fffffff376c)));
      arg2 = vcombine_s8(vcreate_s8(UINT64_C(0x93e97f7f7f7f00ff)),
                         vcreate_s8(UINT64_C(0xfcffba00b5fffeff)));
      clear_neon_saturated();
      //  Expect: "result" = 00c000ffffff0d360000000000007f3f
      result = vshlq_s8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result), 0);
         exp = UINT64_C(0x0000000000007f3f);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result), 1);
         exp = UINT64_C(0x00c000ffffff0d36);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_847() {

{
   {
      int16x8_t arg1;
      int16x8_t arg2;
      int16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"shl\", fnname = \"vshlq_s16\", rettype = \"int16x8_t\", argtypes = \"[int16x8_t,int16x8_t]\", vals = [VectorVal [IntegerVal (-1),IntegerVal 0,IntegerVal (-1),IntegerVal 19060,IntegerVal (-32768),IntegerVal (-32768),IntegerVal 0,IntegerVal 0],VectorVal [IntegerVal 0,IntegerVal 32767,IntegerVal 32767,IntegerVal 25564,IntegerVal (-32768),IntegerVal (-32768),IntegerVal (-24209),IntegerVal 1552]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s16(vcreate_s16(UINT64_C(0x4a74ffff0000ffff)),
                          vcreate_s16(UINT64_C(0x0000000080008000)));
      arg2 = vcombine_s16(vcreate_s16(UINT64_C(0x63dc7fff7fff0000)),
                          vcreate_s16(UINT64_C(0x0610a16f80008000)));
      clear_neon_saturated();
      //  Expect: "result" = 00000000800080000000ffff0000ffff
      result = vshlq_s16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 0);
         exp = UINT64_C(0x0000ffff0000ffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 1);
         exp = UINT64_C(0x0000000080008000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_848() {

{
   {
      int32x4_t arg1;
      int32x4_t arg2;
      int32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"shl\", fnname = \"vshlq_s32\", rettype = \"int32x4_t\", argtypes = \"[int32x4_t,int32x4_t]\", vals = [VectorVal [IntegerVal (-65536),IntegerVal (-2147442207),IntegerVal 2147439062,IntegerVal (-440926208)],VectorVal [IntegerVal 2147466003,IntegerVal (-65536),IntegerVal (-1967030272),IntegerVal (-23703)]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s32(vcreate_s32(UINT64_C(0x8000a1e1ffff0000)),
                          vcreate_s32(UINT64_C(0xe5b800007fff51d6)));
      arg2 = vcombine_s32(vcreate_s32(UINT64_C(0xffff00007fffbb13)),
                          vcreate_s32(UINT64_C(0xffffa3698ac18000)));
      clear_neon_saturated();
      //  Expect: "result" = 000000007fff51d68000a1e100000000
      result = vshlq_s32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 0);
         exp = UINT64_C(0x8000a1e100000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 1);
         exp = UINT64_C(0x000000007fff51d6);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_849() {

{
   {
      int64x2_t arg1;
      int64x2_t arg2;
      int64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"shl\", fnname = \"vshlq_s64\", rettype = \"int64x2_t\", argtypes = \"[int64x2_t,int64x2_t]\", vals = [VectorVal [IntegerVal (-9223231299366401280),IntegerVal 6279003038678044993],VectorVal [IntegerVal 140741783322623,IntegerVal (-9223090566172999680)]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s64(vcreate_s64(UINT64_C(0x8000800000004b00)),
                          vcreate_s64(UINT64_C(0x57237fff0000d141)));
      arg2 = vcombine_s64(vcreate_s64(UINT64_C(0x00008000ffffffff)),
                          vcreate_s64(UINT64_C(0x8000ffff00008000)));
      clear_neon_saturated();
      //  Expect: "result" = 57237fff0000d141c000400000002580
      result = vshlq_s64(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 0);
         exp = UINT64_C(0xc000400000002580);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 1);
         exp = UINT64_C(0x57237fff0000d141);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_850() {

{
   {
      uint8x16_t arg1;
      int8x16_t arg2;
      uint8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"shl\", fnname = \"vshlq_u8\", rettype = \"uint8x16_t\", argtypes = \"[uint8x16_t,int8x16_t]\", vals = [VectorVal [IntegerVal 239,IntegerVal 127,IntegerVal 128,IntegerVal 255,IntegerVal 127,IntegerVal 0,IntegerVal 0,IntegerVal 21,IntegerVal 127,IntegerVal 176,IntegerVal 127,IntegerVal 0,IntegerVal 255,IntegerVal 0,IntegerVal 80,IntegerVal 128],VectorVal [IntegerVal 0,IntegerVal 117,IntegerVal (-6),IntegerVal (-128),IntegerVal 0,IntegerVal (-128),IntegerVal (-1),IntegerVal (-1),IntegerVal (-1),IntegerVal (-1),IntegerVal 0,IntegerVal 127,IntegerVal 0,IntegerVal (-1),IntegerVal 127,IntegerVal (-1)]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u8(vcreate_u8(UINT64_C(0x1500007fff807fef)),
                         vcreate_u8(UINT64_C(0x805000ff007fb07f)));
      arg2 = vcombine_s8(vcreate_s8(UINT64_C(0xffff800080fa7500)),
                         vcreate_s8(UINT64_C(0xff7fff007f00ffff)));
      clear_neon_saturated();
      //  Expect: "result" = 400000ff007f583f0a00007f000200ef
      result = vshlq_u8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 0);
         exp = UINT64_C(0x0a00007f000200ef);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 1);
         exp = UINT64_C(0x400000ff007f583f);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_851() {

{
   {
      uint16x8_t arg1;
      int16x8_t arg2;
      uint16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"shl\", fnname = \"vshlq_u16\", rettype = \"uint16x8_t\", argtypes = \"[uint16x8_t,int16x8_t]\", vals = [VectorVal [IntegerVal 14812,IntegerVal 65535,IntegerVal 32767,IntegerVal 0,IntegerVal 19019,IntegerVal 32768,IntegerVal 65535,IntegerVal 32767],VectorVal [IntegerVal (-32768),IntegerVal (-31751),IntegerVal 18511,IntegerVal 32767,IntegerVal (-32768),IntegerVal 31583,IntegerVal (-1),IntegerVal (-32768)]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u16(vcreate_u16(UINT64_C(0x00007fffffff39dc)),
                          vcreate_u16(UINT64_C(0x7fffffff80004a4b)));
      arg2 = vcombine_s16(vcreate_s16(UINT64_C(0x7fff484f83f98000)),
                          vcreate_s16(UINT64_C(0x8000ffff7b5f8000)));
      clear_neon_saturated();
      //  Expect: "result" = 7fff7fff00004a4b0000000001ff39dc
      result = vshlq_u16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 0);
         exp = UINT64_C(0x0000000001ff39dc);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 1);
         exp = UINT64_C(0x7fff7fff00004a4b);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_852() {

{
   {
      uint32x4_t arg1;
      int32x4_t arg2;
      uint32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"shl\", fnname = \"vshlq_u32\", rettype = \"uint32x4_t\", argtypes = \"[uint32x4_t,int32x4_t]\", vals = [VectorVal [IntegerVal 332496896,IntegerVal 1802502144,IntegerVal 1636990976,IntegerVal 2147512381],VectorVal [IntegerVal (-1610973184),IntegerVal (-65536),IntegerVal 667975680,IntegerVal (-2147450881)]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u32(vcreate_u32(UINT64_C(0x6b70000013d18000)),
                          vcreate_u32(UINT64_C(0x8000703d61928000)));
      arg2 = vcombine_s32(vcreate_s32(UINT64_C(0xffff00009ffa8000)),
                          vcreate_s32(UINT64_C(0x80007fff27d08000)));
      clear_neon_saturated();
      //  Expect: "result" = 4000381e619280006b70000013d18000
      result = vshlq_u32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 0);
         exp = UINT64_C(0x6b70000013d18000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 1);
         exp = UINT64_C(0x4000381e61928000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_853() {

{
   {
      uint64x2_t arg1;
      int64x2_t arg2;
      uint64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"shl\", fnname = \"vshlq_u64\", rettype = \"uint64x2_t\", argtypes = \"[uint64x2_t,int64x2_t]\", vals = [VectorVal [IntegerVal 9223653510236045312,IntegerVal 11477986604602097663],VectorVal [IntegerVal (-3986670834788925440),IntegerVal 9223372034307260416]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u64(vcreate_u64(UINT64_C(0x8000ffffa0e78000)),
                          vcreate_u64(UINT64_C(0x9f4a0000ffffffff)));
      arg2 = vcombine_s64(vcreate_s64(UINT64_C(0xc8ac7fff7fff0000)),
                          vcreate_s64(UINT64_C(0x7fffffff68280000)));
      clear_neon_saturated();
      //  Expect: "result" = 9f4a0000ffffffff8000ffffa0e78000
      result = vshlq_u64(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 0);
         exp = UINT64_C(0x8000ffffa0e78000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 1);
         exp = UINT64_C(0x9f4a0000ffffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_854() {

{
   {
      int64_t arg1;
      int64_t arg2;
      int64_t result;
      char* str1 = "ReproInfo2 {semantics = \"shl\", fnname = \"vshld_s64\", rettype = \"int64_t\", argtypes = \"[int64_t,int64_t]\", vals = [IntegerVal 3413728517546803199,IntegerVal 9223231299366481879], start_saturated = False}";
      int reported = 0;
      int64_t got;
      int64_t exp;
      arg1 = INT64_C(3413728517546803199);
      arg2 = INT64_C(9223231299366481879);
      clear_neon_saturated();
      //  Expect: "result" = 000000000017afff
      result = vshld_s64(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = INT64_C(1552383);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIi64 " Got: %" PRIi64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_855() {

{
   {
      uint64_t arg1;
      int64_t arg2;
      uint64_t result;
      char* str1 = "ReproInfo2 {semantics = \"shl\", fnname = \"vshld_u64\", rettype = \"uint64_t\", argtypes = \"[uint64_t,int64_t]\", vals = [IntegerVal 5304536675251978240,IntegerVal 9223090566172999679], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = UINT64_C(0x499d8000626d0000);
      arg2 = INT64_C(9223090566172999679);
      clear_neon_saturated();
      //  Expect: "result" = 24cec00031368000
      result = vshld_u64(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = UINT64_C(0x24cec00031368000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_856() {

{
   {
      int8x8_t arg1;
      int8x8_t arg2;
      int8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"qshl\", fnname = \"vqshl_s8\", rettype = \"int8x8_t\", argtypes = \"[int8x8_t,int8x8_t]\", vals = [VectorVal [IntegerVal (-1),IntegerVal 127,IntegerVal (-128),IntegerVal (-100),IntegerVal 127,IntegerVal (-1),IntegerVal (-128),IntegerVal (-1)],VectorVal [IntegerVal (-48),IntegerVal (-128),IntegerVal (-31),IntegerVal 127,IntegerVal 127,IntegerVal 127,IntegerVal 127,IntegerVal (-128)]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s8(UINT64_C(0xff80ff7f9c807fff));
      arg2 = vcreate_s8(UINT64_C(0x807f7f7f7fe180d0));
      clear_neon_saturated();
      //  Expect: "result" = ff80807f80ff00ff
      result = vqshl_s8(arg1, arg2);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s8(result), 0);
      exp = UINT64_C(0xff80807f80ff00ff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_857() {

{
   {
      int16x4_t arg1;
      int16x4_t arg2;
      int16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"qshl\", fnname = \"vqshl_s16\", rettype = \"int16x4_t\", argtypes = \"[int16x4_t,int16x4_t]\", vals = [VectorVal [IntegerVal 32767,IntegerVal 30839,IntegerVal (-1),IntegerVal (-28181)],VectorVal [IntegerVal (-32768),IntegerVal 32767,IntegerVal 0,IntegerVal (-1)]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s16(UINT64_C(0x91ebffff78777fff));
      arg2 = vcreate_s16(UINT64_C(0xffff00007fff8000));
      clear_neon_saturated();
      //  Expect: "result" = c8f5ffff3c3b7fff
      result = vqshl_s16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s16(result), 0);
      exp = UINT64_C(0xc8f5ffff3c3b7fff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_858() {

{
   {
      int32x2_t arg1;
      int32x2_t arg2;
      int32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"qshl\", fnname = \"vqshl_s32\", rettype = \"int32x2_t\", argtypes = \"[int32x2_t,int32x2_t]\", vals = [VectorVal [IntegerVal 2147450880,IntegerVal (-2147483648)],VectorVal [IntegerVal 65535,IntegerVal 32768]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s32(UINT64_C(0x800000007fff8000));
      arg2 = vcreate_s32(UINT64_C(0x000080000000ffff));
      clear_neon_saturated();
      //  Expect: "result" = 800000003fffc000
      result = vqshl_s32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s32(result), 0);
      exp = UINT64_C(0x800000003fffc000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_859() {

{
   {
      int64x1_t arg1;
      int64x1_t arg2;
      int64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"qshl\", fnname = \"vqshl_s64\", rettype = \"int64x1_t\", argtypes = \"[int64x1_t,int64x1_t]\", vals = [VectorVal [IntegerVal (-9223231303661387776)],VectorVal [IntegerVal (-4294936350)]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s64(UINT64_C(0x80007fff00000000));
      arg2 = vcreate_s64(UINT64_C(0xffffffff000078e2));
      clear_neon_saturated();
      //  Expect: "result" = fffffffe0001fffc
      result = vqshl_s64(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s64(result), 0);
      exp = UINT64_C(0xfffffffe0001fffc);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_860() {

{
   {
      uint8x8_t arg1;
      int8x8_t arg2;
      uint8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"qshl\", fnname = \"vqshl_u8\", rettype = \"uint8x8_t\", argtypes = \"[uint8x8_t,int8x8_t]\", vals = [VectorVal [IntegerVal 128,IntegerVal 127,IntegerVal 0,IntegerVal 255,IntegerVal 128,IntegerVal 128,IntegerVal 128,IntegerVal 127],VectorVal [IntegerVal 80,IntegerVal 0,IntegerVal 0,IntegerVal (-83),IntegerVal (-1),IntegerVal (-1),IntegerVal (-1),IntegerVal (-1)]], start_saturated = True}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u8(UINT64_C(0x7f808080ff007f80));
      arg2 = vcreate_s8(UINT64_C(0xffffffffad000050));
      set_neon_saturated();
      //  Expect: "result" = 3f40404000007fff
      result = vqshl_u8(arg1, arg2);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u8(result), 0);
      exp = UINT64_C(0x3f40404000007fff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_861() {

{
   {
      uint16x4_t arg1;
      int16x4_t arg2;
      uint16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"qshl\", fnname = \"vqshl_u16\", rettype = \"uint16x4_t\", argtypes = \"[uint16x4_t,int16x4_t]\", vals = [VectorVal [IntegerVal 32767,IntegerVal 32767,IntegerVal 32768,IntegerVal 0],VectorVal [IntegerVal 32767,IntegerVal 18213,IntegerVal (-1),IntegerVal (-32768)]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u16(UINT64_C(0x000080007fff7fff));
      arg2 = vcreate_s16(UINT64_C(0x8000ffff47257fff));
      clear_neon_saturated();
      //  Expect: "result" = 00004000ffff3fff
      result = vqshl_u16(arg1, arg2);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u16(result), 0);
      exp = UINT64_C(0x00004000ffff3fff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_862() {

{
   {
      uint32x2_t arg1;
      int32x2_t arg2;
      uint32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"qshl\", fnname = \"vqshl_u32\", rettype = \"uint32x2_t\", argtypes = \"[uint32x2_t,int32x2_t]\", vals = [VectorVal [IntegerVal 2147539244,IntegerVal 4294967295],VectorVal [IntegerVal 2147430662,IntegerVal 2147483647]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u32(UINT64_C(0xffffffff8000d92c));
      arg2 = vcreate_s32(UINT64_C(0x7fffffff7fff3106));
      clear_neon_saturated();
      //  Expect: "result" = 7fffffffffffffff
      result = vqshl_u32(arg1, arg2);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u32(result), 0);
      exp = UINT64_C(0x7fffffffffffffff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_863() {

{
   {
      uint64x1_t arg1;
      int64x1_t arg2;
      uint64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"qshl\", fnname = \"vqshl_u64\", rettype = \"uint64x1_t\", argtypes = \"[uint64x1_t,int64x1_t]\", vals = [VectorVal [IntegerVal 18446734753630486528],VectorVal [IntegerVal (-140733470670849)]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u64(UINT64_C(0xfffff785ffff8000));
      arg2 = vcreate_s64(UINT64_C(0xffff8000ef78ffff));
      clear_neon_saturated();
      //  Expect: "result" = 7ffffbc2ffffc000
      result = vqshl_u64(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(result, 0);
      exp = UINT64_C(0x7ffffbc2ffffc000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_864() {

{
   {
      int8x16_t arg1;
      int8x16_t arg2;
      int8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"qshl\", fnname = \"vqshlq_s8\", rettype = \"int8x16_t\", argtypes = \"[int8x16_t,int8x16_t]\", vals = [VectorVal [IntegerVal (-128),IntegerVal 19,IntegerVal 0,IntegerVal (-128),IntegerVal (-128),IntegerVal 0,IntegerVal (-1),IntegerVal (-128),IntegerVal 0,IntegerVal (-128),IntegerVal (-1),IntegerVal (-1),IntegerVal (-128),IntegerVal 127,IntegerVal 127,IntegerVal 23],VectorVal [IntegerVal (-1),IntegerVal (-102),IntegerVal (-128),IntegerVal (-1),IntegerVal (-59),IntegerVal 127,IntegerVal 127,IntegerVal (-128),IntegerVal (-1),IntegerVal (-128),IntegerVal (-1),IntegerVal (-128),IntegerVal 103,IntegerVal (-1),IntegerVal 0,IntegerVal (-1)]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s8(vcreate_s8(UINT64_C(0x80ff008080001380)),
                         vcreate_s8(UINT64_C(0x177f7f80ffff8000)));
      arg2 = vcombine_s8(vcreate_s8(UINT64_C(0x807f7fc5ff809aff)),
                         vcreate_s8(UINT64_C(0xff00ff6780ff80ff)));
      clear_neon_saturated();
      //  Expect: "result" = 0b7f3f80ffffff00ff8000ffc00000c0
      result = vqshlq_s8(arg1, arg2);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result), 0);
         exp = UINT64_C(0xff8000ffc00000c0);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result), 1);
         exp = UINT64_C(0x0b7f3f80ffffff00);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_865() {

{
   {
      int16x8_t arg1;
      int16x8_t arg2;
      int16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"qshl\", fnname = \"vqshlq_s16\", rettype = \"int16x8_t\", argtypes = \"[int16x8_t,int16x8_t]\", vals = [VectorVal [IntegerVal (-32768),IntegerVal 4058,IntegerVal (-1),IntegerVal 32767,IntegerVal 0,IntegerVal (-32768),IntegerVal 32767,IntegerVal (-1)],VectorVal [IntegerVal 32767,IntegerVal 32767,IntegerVal 0,IntegerVal 32767,IntegerVal 32767,IntegerVal 32767,IntegerVal 0,IntegerVal (-17087)]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s16(vcreate_s16(UINT64_C(0x7fffffff0fda8000)),
                          vcreate_s16(UINT64_C(0xffff7fff80000000)));
      arg2 = vcombine_s16(vcreate_s16(UINT64_C(0x7fff00007fff7fff)),
                          vcreate_s16(UINT64_C(0xbd4100007fff7fff)));
      clear_neon_saturated();
      //  Expect: "result" = 80007fffc00000003fffffff07edc000
      result = vqshlq_s16(arg1, arg2);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 0);
         exp = UINT64_C(0x3fffffff07edc000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 1);
         exp = UINT64_C(0x80007fffc0000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_866() {

{
   {
      int32x4_t arg1;
      int32x4_t arg2;
      int32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"qshl\", fnname = \"vqshlq_s32\", rettype = \"int32x4_t\", argtypes = \"[int32x4_t,int32x4_t]\", vals = [VectorVal [IntegerVal 0,IntegerVal (-29897),IntegerVal (-65536),IntegerVal 1658748928],VectorVal [IntegerVal 2147423907,IntegerVal (-2147450881),IntegerVal 2147450879,IntegerVal (-32768)]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s32(vcreate_s32(UINT64_C(0xffff8b3700000000)),
                          vcreate_s32(UINT64_C(0x62de8000ffff0000)));
      arg2 = vcombine_s32(vcreate_s32(UINT64_C(0x80007fff7fff16a3)),
                          vcreate_s32(UINT64_C(0xffff80007fff7fff)));
      clear_neon_saturated();
      //  Expect: "result" = 62de8000ffff8000ffffc59b00000000
      result = vqshlq_s32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 0);
         exp = UINT64_C(0xffffc59b00000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 1);
         exp = UINT64_C(0x62de8000ffff8000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_867() {

{
   {
      int64x2_t arg1;
      int64x2_t arg2;
      int64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"qshl\", fnname = \"vqshlq_s64\", rettype = \"int64x2_t\", argtypes = \"[int64x2_t,int64x2_t]\", vals = [VectorVal [IntegerVal 9223372032559814292,IntegerVal (-4847984261375983616)],VectorVal [IntegerVal (-9223372032559841281),IntegerVal (-9223279156039483393)]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s64(vcreate_s64(UINT64_C(0x7fffffff00001694)),
                          vcreate_s64(UINT64_C(0xbcb8800000000000)));
      arg2 = vcombine_s64(vcreate_s64(UINT64_C(0x80000000ffff7fff)),
                          vcreate_s64(UINT64_C(0x8000547980007fff)));
      clear_neon_saturated();
      //  Expect: "result" = de5c4000000000003fffffff80000b4a
      result = vqshlq_s64(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 0);
         exp = UINT64_C(0x3fffffff80000b4a);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 1);
         exp = UINT64_C(0xde5c400000000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_868() {

{
   {
      uint8x16_t arg1;
      int8x16_t arg2;
      uint8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"qshl\", fnname = \"vqshlq_u8\", rettype = \"uint8x16_t\", argtypes = \"[uint8x16_t,int8x16_t]\", vals = [VectorVal [IntegerVal 127,IntegerVal 255,IntegerVal 0,IntegerVal 127,IntegerVal 255,IntegerVal 255,IntegerVal 127,IntegerVal 255,IntegerVal 255,IntegerVal 232,IntegerVal 127,IntegerVal 127,IntegerVal 128,IntegerVal 128,IntegerVal 43,IntegerVal 167],VectorVal [IntegerVal 127,IntegerVal 0,IntegerVal (-128),IntegerVal (-128),IntegerVal 83,IntegerVal (-64),IntegerVal (-1),IntegerVal 42,IntegerVal 0,IntegerVal 14,IntegerVal (-27),IntegerVal 127,IntegerVal (-128),IntegerVal (-128),IntegerVal 0,IntegerVal 57]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u8(vcreate_u8(UINT64_C(0xff7fffff7f00ff7f)),
                         vcreate_u8(UINT64_C(0xa72b80807f7fe8ff)));
      arg2 = vcombine_s8(vcreate_s8(UINT64_C(0x2affc0538080007f)),
                         vcreate_s8(UINT64_C(0x390080807fe50e00)));
      clear_neon_saturated();
      //  Expect: "result" = ff2b0000ff00ffffff3f00ff0000ffff
      result = vqshlq_u8(arg1, arg2);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 0);
         exp = UINT64_C(0xff3f00ff0000ffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 1);
         exp = UINT64_C(0xff2b0000ff00ffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_869() {

{
   {
      uint16x8_t arg1;
      int16x8_t arg2;
      uint16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"qshl\", fnname = \"vqshlq_u16\", rettype = \"uint16x8_t\", argtypes = \"[uint16x8_t,int16x8_t]\", vals = [VectorVal [IntegerVal 32768,IntegerVal 32768,IntegerVal 0,IntegerVal 65535,IntegerVal 65535,IntegerVal 32767,IntegerVal 32768,IntegerVal 65535],VectorVal [IntegerVal (-32768),IntegerVal 32767,IntegerVal 10802,IntegerVal (-32768),IntegerVal 29087,IntegerVal (-1),IntegerVal (-32768),IntegerVal 0]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u16(vcreate_u16(UINT64_C(0xffff000080008000)),
                          vcreate_u16(UINT64_C(0xffff80007fffffff)));
      arg2 = vcombine_s16(vcreate_s16(UINT64_C(0x80002a327fff8000)),
                          vcreate_s16(UINT64_C(0x00008000ffff719f)));
      clear_neon_saturated();
      //  Expect: "result" = ffff80003fff0000ffff000040008000
      result = vqshlq_u16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 0);
         exp = UINT64_C(0xffff000040008000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 1);
         exp = UINT64_C(0xffff80003fff0000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_870() {

{
   {
      uint32x4_t arg1;
      int32x4_t arg2;
      uint32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"qshl\", fnname = \"vqshlq_u32\", rettype = \"uint32x4_t\", argtypes = \"[uint32x4_t,int32x4_t]\", vals = [VectorVal [IntegerVal 2147537843,IntegerVal 4294934528,IntegerVal 4294934528,IntegerVal 65535],VectorVal [IntegerVal 32767,IntegerVal 0,IntegerVal 2147483647,IntegerVal 0]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u32(vcreate_u32(UINT64_C(0xffff80008000d3b3)),
                          vcreate_u32(UINT64_C(0x0000ffffffff8000)));
      arg2 = vcombine_s32(vcreate_s32(UINT64_C(0x0000000000007fff)),
                          vcreate_s32(UINT64_C(0x000000007fffffff)));
      clear_neon_saturated();
      //  Expect: "result" = 0000ffff7fffc000ffff8000400069d9
      result = vqshlq_u32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 0);
         exp = UINT64_C(0xffff8000400069d9);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 1);
         exp = UINT64_C(0x0000ffff7fffc000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_871() {

{
   {
      uint64x2_t arg1;
      int64x2_t arg2;
      uint64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"qshl\", fnname = \"vqshlq_u64\", rettype = \"uint64x2_t\", argtypes = \"[uint64x2_t,int64x2_t]\", vals = [VectorVal [IntegerVal 18446603336221238935,IntegerVal 140739635871744],VectorVal [IntegerVal 9223372032559874047,IntegerVal (-9223231301513936897)]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u64(vcreate_u64(UINT64_C(0xffff80000000a697)),
                          vcreate_u64(UINT64_C(0x0000800080008000)));
      arg2 = vcombine_s64(vcreate_s64(UINT64_C(0x7fffffff0000ffff)),
                          vcreate_s64(UINT64_C(0x80007fff7fff7fff)));
      clear_neon_saturated();
      //  Expect: "result" = 00004000400040007fffc0000000534b
      result = vqshlq_u64(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 0);
         exp = UINT64_C(0x7fffc0000000534b);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 1);
         exp = UINT64_C(0x0000400040004000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_872() {

{
   {
      int8_t arg1;
      int8_t arg2;
      int8_t result;
      char* str1 = "ReproInfo2 {semantics = \"qshl\", fnname = \"vqshlb_s8\", rettype = \"int8_t\", argtypes = \"[int8_t,int8_t]\", vals = [IntegerVal 78,IntegerVal 127], start_saturated = False}";
      int reported = 0;
      int8_t got;
      int8_t exp;
      arg1 = 78;
      arg2 = 127;
      clear_neon_saturated();
      //  Expect: "result" = 7f
      result = vqshlb_s8(arg1, arg2);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      got = result;
      exp = 127;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_873() {

{
   {
      int16_t arg1;
      int16_t arg2;
      int16_t result;
      char* str1 = "ReproInfo2 {semantics = \"qshl\", fnname = \"vqshlh_s16\", rettype = \"int16_t\", argtypes = \"[int16_t,int16_t]\", vals = [IntegerVal 0,IntegerVal 32767], start_saturated = True}";
      int reported = 0;
      int16_t got;
      int16_t exp;
      arg1 = 0;
      arg2 = 32767;
      set_neon_saturated();
      //  Expect: "result" = 0000
      result = vqshlh_s16(arg1, arg2);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      got = result;
      exp = 0;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIi16 " Got: %" PRIi16 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_874() {

{
   {
      int32_t arg1;
      int32_t arg2;
      int32_t result;
      char* str1 = "ReproInfo2 {semantics = \"qshl\", fnname = \"vqshls_s32\", rettype = \"int32_t\", argtypes = \"[int32_t,int32_t]\", vals = [IntegerVal (-23705),IntegerVal (-370284259)], start_saturated = False}";
      int reported = 0;
      int32_t got;
      int32_t exp;
      arg1 = -23705;
      arg2 = -370284259;
      clear_neon_saturated();
      //  Expect: "result" = 80000000
      result = vqshls_s32(arg1, arg2);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      got = result;
      exp = (int32_t) 0x80000000;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIi32 " Got: %" PRIi32 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_875() {

{
   {
      int64_t arg1;
      int64_t arg2;
      int64_t result;
      char* str1 = "ReproInfo2 {semantics = \"qshl\", fnname = \"vqshld_s64\", rettype = \"int64_t\", argtypes = \"[int64_t,int64_t]\", vals = [IntegerVal (-9223231303661322241),IntegerVal (-140739635838976)], start_saturated = False}";
      int reported = 0;
      int64_t got;
      int64_t exp;
      arg1 = INT64_C(-9223231303661322241);
      arg2 = INT64_C(-140739635838976);
      clear_neon_saturated();
      //  Expect: "result" = 80007fff0000ffff
      result = vqshld_s64(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = INT64_C(-9223231303661322241);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIi64 " Got: %" PRIi64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_876() {

{
   {
      uint8_t arg1;
      int8_t arg2;
      uint8_t result;
      char* str1 = "ReproInfo2 {semantics = \"qshl\", fnname = \"vqshlb_u8\", rettype = \"uint8_t\", argtypes = \"[uint8_t,int8_t]\", vals = [IntegerVal 127,IntegerVal (-128)], start_saturated = False}";
      int reported = 0;
      uint8_t got;
      uint8_t exp;
      arg1 = 127U;
      arg2 = -128;
      clear_neon_saturated();
      //  Expect: "result" = 00
      result = vqshlb_u8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = 0;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_877() {

{
   {
      uint16_t arg1;
      int16_t arg2;
      uint16_t result;
      char* str1 = "ReproInfo2 {semantics = \"qshl\", fnname = \"vqshlh_u16\", rettype = \"uint16_t\", argtypes = \"[uint16_t,int16_t]\", vals = [IntegerVal 38845,IntegerVal (-21912)], start_saturated = False}";
      int reported = 0;
      uint16_t got;
      uint16_t exp;
      arg1 = 38845U;
      arg2 = -21912;
      clear_neon_saturated();
      //  Expect: "result" = ffff
      result = vqshlh_u16(arg1, arg2);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      got = result;
      exp = 65535U;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_878() {

{
   {
      uint32_t arg1;
      int32_t arg2;
      uint32_t result;
      char* str1 = "ReproInfo2 {semantics = \"qshl\", fnname = \"vqshls_u32\", rettype = \"uint32_t\", argtypes = \"[uint32_t,int32_t]\", vals = [IntegerVal 1966250755,IntegerVal 355205119], start_saturated = False}";
      int reported = 0;
      uint32_t got;
      uint32_t exp;
      arg1 = 1966250755U;
      arg2 = 355205119;
      clear_neon_saturated();
      //  Expect: "result" = 3a994d81
      result = vqshls_u32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = 983125377U;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIu32 " Got: %" PRIu32 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_879() {

{
   {
      uint64_t arg1;
      int64_t arg2;
      uint64_t result;
      char* str1 = "ReproInfo2 {semantics = \"qshl\", fnname = \"vqshld_u64\", rettype = \"uint64_t\", argtypes = \"[uint64_t,int64_t]\", vals = [IntegerVal 9223231297218936831,IntegerVal 281472829161472], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = UINT64_C(0x7fff7fff7fffffff);
      arg2 = INT64_C(281472829161472);
      clear_neon_saturated();
      //  Expect: "result" = 7fff7fff7fffffff
      result = vqshld_u64(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = UINT64_C(0x7fff7fff7fffffff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_880() {

{
   {
      int8x8_t arg1;
      int8x8_t arg2;
      int8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"rshl\", fnname = \"vrshl_s8\", rettype = \"int8x8_t\", argtypes = \"[int8x8_t,int8x8_t]\", vals = [VectorVal [IntegerVal 120,IntegerVal (-100),IntegerVal (-128),IntegerVal 127,IntegerVal 1,IntegerVal 127,IntegerVal (-1),IntegerVal 127],VectorVal [IntegerVal 0,IntegerVal 127,IntegerVal 127,IntegerVal 0,IntegerVal 127,IntegerVal 117,IntegerVal (-128),IntegerVal 127]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s8(UINT64_C(0x7fff7f017f809c78));
      arg2 = vcreate_s8(UINT64_C(0x7f80757f007f7f00));
      clear_neon_saturated();
      //  Expect: "result" = 000000007f000078
      result = vrshl_s8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s8(result), 0);
      exp = UINT64_C(0x000000007f000078);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_881() {

{
   {
      int16x4_t arg1;
      int16x4_t arg2;
      int16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"rshl\", fnname = \"vrshl_s16\", rettype = \"int16x4_t\", argtypes = \"[int16x4_t,int16x4_t]\", vals = [VectorVal [IntegerVal (-32768),IntegerVal (-32768),IntegerVal 0,IntegerVal 32767],VectorVal [IntegerVal (-32768),IntegerVal (-1),IntegerVal 0,IntegerVal 32767]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s16(UINT64_C(0x7fff000080008000));
      arg2 = vcreate_s16(UINT64_C(0x7fff0000ffff8000));
      clear_neon_saturated();
      //  Expect: "result" = 40000000c0008000
      result = vrshl_s16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s16(result), 0);
      exp = UINT64_C(0x40000000c0008000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_882() {

{
   {
      int32x2_t arg1;
      int32x2_t arg2;
      int32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"rshl\", fnname = \"vrshl_s32\", rettype = \"int32x2_t\", argtypes = \"[int32x2_t,int32x2_t]\", vals = [VectorVal [IntegerVal 32767,IntegerVal (-65536)],VectorVal [IntegerVal (-2147483648),IntegerVal 65535]], start_saturated = True}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s32(UINT64_C(0xffff000000007fff));
      arg2 = vcreate_s32(UINT64_C(0x0000ffff80000000));
      set_neon_saturated();
      //  Expect: "result" = ffff800000007fff
      result = vrshl_s32(arg1, arg2);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s32(result), 0);
      exp = UINT64_C(0xffff800000007fff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_883() {

{
   {
      int64x1_t arg1;
      int64x1_t arg2;
      int64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"rshl\", fnname = \"vrshl_s64\", rettype = \"int64x1_t\", argtypes = \"[int64x1_t,int64x1_t]\", vals = [VectorVal [IntegerVal 609026047],VectorVal [IntegerVal (-100905961684993)]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s64(UINT64_C(0x00000000244cffff));
      arg2 = vcreate_s64(UINT64_C(0xffffa439ffff7fff));
      clear_neon_saturated();
      //  Expect: "result" = 0000000012268000
      result = vrshl_s64(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s64(result), 0);
      exp = UINT64_C(0x0000000012268000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_884() {

{
   {
      uint8x8_t arg1;
      int8x8_t arg2;
      uint8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"rshl\", fnname = \"vrshl_u8\", rettype = \"uint8x8_t\", argtypes = \"[uint8x8_t,int8x8_t]\", vals = [VectorVal [IntegerVal 255,IntegerVal 255,IntegerVal 255,IntegerVal 127,IntegerVal 255,IntegerVal 127,IntegerVal 128,IntegerVal 255],VectorVal [IntegerVal (-98),IntegerVal (-57),IntegerVal (-78),IntegerVal (-128),IntegerVal 0,IntegerVal (-16),IntegerVal 127,IntegerVal 0]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u8(UINT64_C(0xff807fff7fffffff));
      arg2 = vcreate_s8(UINT64_C(0x007ff00080b2c79e));
      clear_neon_saturated();
      //  Expect: "result" = ff0000ff00000000
      result = vrshl_u8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u8(result), 0);
      exp = UINT64_C(0xff0000ff00000000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_885() {

{
   {
      uint16x4_t arg1;
      int16x4_t arg2;
      uint16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"rshl\", fnname = \"vrshl_u16\", rettype = \"uint16x4_t\", argtypes = \"[uint16x4_t,int16x4_t]\", vals = [VectorVal [IntegerVal 32768,IntegerVal 32767,IntegerVal 49393,IntegerVal 0],VectorVal [IntegerVal (-1),IntegerVal (-1),IntegerVal (-32768),IntegerVal 0]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u16(UINT64_C(0x0000c0f17fff8000));
      arg2 = vcreate_s16(UINT64_C(0x00008000ffffffff));
      clear_neon_saturated();
      //  Expect: "result" = 0000c0f140004000
      result = vrshl_u16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u16(result), 0);
      exp = UINT64_C(0x0000c0f140004000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_886() {

{
   {
      uint32x2_t arg1;
      int32x2_t arg2;
      uint32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"rshl\", fnname = \"vrshl_u32\", rettype = \"uint32x2_t\", argtypes = \"[uint32x2_t,int32x2_t]\", vals = [VectorVal [IntegerVal 65535,IntegerVal 4294901760],VectorVal [IntegerVal (-2147450880),IntegerVal (-2147450880)]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u32(UINT64_C(0xffff00000000ffff));
      arg2 = vcreate_s32(UINT64_C(0x8000800080008000));
      clear_neon_saturated();
      //  Expect: "result" = ffff00000000ffff
      result = vrshl_u32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u32(result), 0);
      exp = UINT64_C(0xffff00000000ffff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_887() {

{
   {
      uint64x1_t arg1;
      int64x1_t arg2;
      uint64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"rshl\", fnname = \"vrshl_u64\", rettype = \"uint64x1_t\", argtypes = \"[uint64x1_t,int64x1_t]\", vals = [VectorVal [IntegerVal 18446603334073712640],VectorVal [IntegerVal (-281471427379201)]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u64(UINT64_C(0xffff7fff80000000));
      arg2 = vcreate_s64(UINT64_C(0xffff0000d38e7fff));
      clear_neon_saturated();
      //  Expect: "result" = 7fffbfffc0000000
      result = vrshl_u64(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(result, 0);
      exp = UINT64_C(0x7fffbfffc0000000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_888() {

{
   {
      int8x16_t arg1;
      int8x16_t arg2;
      int8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"rshl\", fnname = \"vrshlq_s8\", rettype = \"int8x16_t\", argtypes = \"[int8x16_t,int8x16_t]\", vals = [VectorVal [IntegerVal 0,IntegerVal (-26),IntegerVal 0,IntegerVal 127,IntegerVal (-128),IntegerVal (-1),IntegerVal 0,IntegerVal (-1),IntegerVal 0,IntegerVal (-1),IntegerVal (-128),IntegerVal (-1),IntegerVal (-1),IntegerVal 127,IntegerVal (-32),IntegerVal 127],VectorVal [IntegerVal 0,IntegerVal 0,IntegerVal (-128),IntegerVal (-6),IntegerVal 21,IntegerVal 0,IntegerVal (-49),IntegerVal (-1),IntegerVal (-1),IntegerVal 127,IntegerVal 127,IntegerVal (-128),IntegerVal (-1),IntegerVal 0,IntegerVal (-1),IntegerVal (-128)]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s8(vcreate_s8(UINT64_C(0xff00ff807f00e600)),
                         vcreate_s8(UINT64_C(0x7fe07fffff80ff00)));
      arg2 = vcombine_s8(vcreate_s8(UINT64_C(0xffcf0015fa800000)),
                         vcreate_s8(UINT64_C(0x80ff00ff807f7fff)));
      clear_neon_saturated();
      //  Expect: "result" = 00f07f00000000000000ff000200e600
      result = vrshlq_s8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result), 0);
         exp = UINT64_C(0x0000ff000200e600);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result), 1);
         exp = UINT64_C(0x00f07f0000000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_889() {

{
   {
      int16x8_t arg1;
      int16x8_t arg2;
      int16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"rshl\", fnname = \"vrshlq_s16\", rettype = \"int16x8_t\", argtypes = \"[int16x8_t,int16x8_t]\", vals = [VectorVal [IntegerVal 0,IntegerVal 0,IntegerVal (-32768),IntegerVal 32767,IntegerVal 21280,IntegerVal (-19519),IntegerVal 22892,IntegerVal 0],VectorVal [IntegerVal 32767,IntegerVal (-1),IntegerVal 0,IntegerVal (-32768),IntegerVal (-1),IntegerVal 0,IntegerVal 0,IntegerVal 0]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s16(vcreate_s16(UINT64_C(0x7fff800000000000)),
                          vcreate_s16(UINT64_C(0x0000596cb3c15320)));
      arg2 = vcombine_s16(vcreate_s16(UINT64_C(0x80000000ffff7fff)),
                          vcreate_s16(UINT64_C(0x000000000000ffff)));
      clear_neon_saturated();
      //  Expect: "result" = 0000596cb3c129907fff800000000000
      result = vrshlq_s16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 0);
         exp = UINT64_C(0x7fff800000000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 1);
         exp = UINT64_C(0x0000596cb3c12990);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_890() {

{
   {
      int32x4_t arg1;
      int32x4_t arg2;
      int32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"rshl\", fnname = \"vrshlq_s32\", rettype = \"int32x4_t\", argtypes = \"[int32x4_t,int32x4_t]\", vals = [VectorVal [IntegerVal 2147483647,IntegerVal 2147450880,IntegerVal 2147418112,IntegerVal 65535],VectorVal [IntegerVal 2147418112,IntegerVal (-1882914816),IntegerVal (-1958182217),IntegerVal 557449215]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s32(vcreate_s32(UINT64_C(0x7fff80007fffffff)),
                          vcreate_s32(UINT64_C(0x0000ffff7fff0000)));
      arg2 = vcombine_s32(vcreate_s32(UINT64_C(0x8fc500007fff0000)),
                          vcreate_s32(UINT64_C(0x2139ffff8b4882b7)));
      clear_neon_saturated();
      //  Expect: "result" = 00008000000000007fff80007fffffff
      result = vrshlq_s32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 0);
         exp = UINT64_C(0x7fff80007fffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 1);
         exp = UINT64_C(0x0000800000000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_891() {

{
   {
      int64x2_t arg1;
      int64x2_t arg2;
      int64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"rshl\", fnname = \"vrshlq_s64\", rettype = \"int64x2_t\", argtypes = \"[int64x2_t,int64x2_t]\", vals = [VectorVal [IntegerVal 9223145681340792832,IntegerVal (-2414210875247263745)],VectorVal [IntegerVal 9223090564025516031,IntegerVal 9223164903569051801]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s64(vcreate_s64(UINT64_C(0x7fff32217fff0000)),
                          vcreate_s64(UINT64_C(0xde7f000000007fff)));
      arg2 = vcombine_s64(vcreate_s64(UINT64_C(0x7fff00007fff7fff)),
                          vcreate_s64(UINT64_C(0x7fff439d06155099)));
      clear_neon_saturated();
      //  Expect: "result" = 00000000000000003fff9910bfff8000
      result = vrshlq_s64(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 0);
         exp = UINT64_C(0x3fff9910bfff8000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 1);
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_892() {

{
   {
      uint8x16_t arg1;
      int8x16_t arg2;
      uint8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"rshl\", fnname = \"vrshlq_u8\", rettype = \"uint8x16_t\", argtypes = \"[uint8x16_t,int8x16_t]\", vals = [VectorVal [IntegerVal 0,IntegerVal 127,IntegerVal 255,IntegerVal 128,IntegerVal 128,IntegerVal 28,IntegerVal 255,IntegerVal 0,IntegerVal 127,IntegerVal 0,IntegerVal 0,IntegerVal 0,IntegerVal 255,IntegerVal 255,IntegerVal 128,IntegerVal 148],VectorVal [IntegerVal (-128),IntegerVal 127,IntegerVal 0,IntegerVal (-56),IntegerVal (-44),IntegerVal 0,IntegerVal (-128),IntegerVal (-128),IntegerVal (-1),IntegerVal 0,IntegerVal 127,IntegerVal 121,IntegerVal (-1),IntegerVal 0,IntegerVal 127,IntegerVal (-1)]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u8(vcreate_u8(UINT64_C(0x00ff1c8080ff7f00)),
                         vcreate_u8(UINT64_C(0x9480ffff0000007f)));
      arg2 = vcombine_s8(vcreate_s8(UINT64_C(0x808000d4c8007f80)),
                         vcreate_s8(UINT64_C(0xff7f00ff797f00ff)));
      clear_neon_saturated();
      //  Expect: "result" = 4a00ff800000004000001c0000ff0000
      result = vrshlq_u8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 0);
         exp = UINT64_C(0x00001c0000ff0000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 1);
         exp = UINT64_C(0x4a00ff8000000040);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_893() {

{
   {
      uint16x8_t arg1;
      int16x8_t arg2;
      uint16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"rshl\", fnname = \"vrshlq_u16\", rettype = \"uint16x8_t\", argtypes = \"[uint16x8_t,int16x8_t]\", vals = [VectorVal [IntegerVal 32768,IntegerVal 0,IntegerVal 41529,IntegerVal 65535,IntegerVal 32768,IntegerVal 32768,IntegerVal 32767,IntegerVal 0],VectorVal [IntegerVal 18450,IntegerVal 32767,IntegerVal (-32768),IntegerVal (-32768),IntegerVal (-32768),IntegerVal 32767,IntegerVal 32767,IntegerVal (-32768)]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u16(vcreate_u16(UINT64_C(0xffffa23900008000)),
                          vcreate_u16(UINT64_C(0x00007fff80008000)));
      arg2 = vcombine_s16(vcreate_s16(UINT64_C(0x800080007fff4812)),
                          vcreate_s16(UINT64_C(0x80007fff7fff8000)));
      clear_neon_saturated();
      //  Expect: "result" = 0000400040008000ffffa23900000000
      result = vrshlq_u16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 0);
         exp = UINT64_C(0xffffa23900000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 1);
         exp = UINT64_C(0x0000400040008000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_894() {

{
   {
      uint32x4_t arg1;
      int32x4_t arg2;
      uint32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"rshl\", fnname = \"vrshlq_u32\", rettype = \"uint32x4_t\", argtypes = \"[uint32x4_t,int32x4_t]\", vals = [VectorVal [IntegerVal 32767,IntegerVal 4294934528,IntegerVal 750720637,IntegerVal 2855108607],VectorVal [IntegerVal 26634,IntegerVal 1063583743,IntegerVal 0,IntegerVal 1384546303]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u32(vcreate_u32(UINT64_C(0xffff800000007fff)),
                          vcreate_u32(UINT64_C(0xaa2d7fff2cbf167d)));
      arg2 = vcombine_s32(vcreate_s32(UINT64_C(0x3f64ffff0000680a)),
                          vcreate_s32(UINT64_C(0x52867fff00000000)));
      clear_neon_saturated();
      //  Expect: "result" = 5516c0002cbf167d7fffc00001fffc00
      result = vrshlq_u32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 0);
         exp = UINT64_C(0x7fffc00001fffc00);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 1);
         exp = UINT64_C(0x5516c0002cbf167d);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_895() {

{
   {
      uint64x2_t arg1;
      int64x2_t arg2;
      uint64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"rshl\", fnname = \"vrshlq_u64\", rettype = \"uint64x2_t\", argtypes = \"[uint64x2_t,int64x2_t]\", vals = [VectorVal [IntegerVal 140735340806144,IntegerVal 18446462600880324513],VectorVal [IntegerVal 9223090564025562263,IntegerVal 9223090564025548799]], start_saturated = True}";
      int reported = 0;
      arg1 = vcombine_u64(vcreate_u64(UINT64_C(0x00007fff7fff0000)),
                          vcreate_u64(UINT64_C(0xffff00007fffffa1)));
      arg2 = vcombine_s64(vcreate_s64(UINT64_C(0x7fff000080003497)),
                          vcreate_s64(UINT64_C(0x7fff00007fffffff)));
      set_neon_saturated();
      //  Expect: "result" = 7fff80003fffffd10000000000000000
      result = vrshlq_u64(arg1, arg2);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 0);
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 1);
         exp = UINT64_C(0x7fff80003fffffd1);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_896() {

{
   {
      int64_t arg1;
      int64_t arg2;
      int64_t result;
      char* str1 = "ReproInfo2 {semantics = \"rshl\", fnname = \"vrshld_s64\", rettype = \"int64_t\", argtypes = \"[int64_t,int64_t]\", vals = [IntegerVal 9223231303661355008,IntegerVal (-9223090565005672449)], start_saturated = False}";
      int reported = 0;
      int64_t got;
      int64_t exp;
      arg1 = INT64_C(9223231303661355008);
      arg2 = INT64_C(-9223090565005672449);
      clear_neon_saturated();
      //  Expect: "result" = 3fffc0007fffc000
      result = vrshld_s64(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = INT64_C(4611615651830677504);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIi64 " Got: %" PRIi64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_897() {

{
   {
      uint64_t arg1;
      int64_t arg2;
      uint64_t result;
      char* str1 = "ReproInfo2 {semantics = \"rshl\", fnname = \"vrshld_u64\", rettype = \"uint64_t\", argtypes = \"[uint64_t,int64_t]\", vals = [IntegerVal 16989688861061775360,IntegerVal (-9223227753870950401)], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = UINT64_C(0xebc78000ffff8000);
      arg2 = INT64_C(-9223227753870950401);
      clear_neon_saturated();
      //  Expect: "result" = 75e3c0007fffc000
      result = vrshld_u64(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = UINT64_C(0x75e3c0007fffc000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_898() {

{
   {
      int8x8_t arg1;
      int8x8_t arg2;
      int8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"qrshl\", fnname = \"vqrshl_s8\", rettype = \"int8x8_t\", argtypes = \"[int8x8_t,int8x8_t]\", vals = [VectorVal [IntegerVal 9,IntegerVal (-128),IntegerVal (-1),IntegerVal 127,IntegerVal 83,IntegerVal 127,IntegerVal (-128),IntegerVal 127],VectorVal [IntegerVal 0,IntegerVal 127,IntegerVal 0,IntegerVal (-128),IntegerVal (-128),IntegerVal 0,IntegerVal 98,IntegerVal 0]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s8(UINT64_C(0x7f807f537fff8009));
      arg2 = vcreate_s8(UINT64_C(0x0062008080007f00));
      clear_neon_saturated();
      //  Expect: "result" = 7f807f0000ff8009
      result = vqrshl_s8(arg1, arg2);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s8(result), 0);
      exp = UINT64_C(0x7f807f0000ff8009);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_899() {

{
   {
      int16x4_t arg1;
      int16x4_t arg2;
      int16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"qrshl\", fnname = \"vqrshl_s16\", rettype = \"int16x4_t\", argtypes = \"[int16x4_t,int16x4_t]\", vals = [VectorVal [IntegerVal 0,IntegerVal 32767,IntegerVal (-32768),IntegerVal 13252],VectorVal [IntegerVal 14145,IntegerVal 0,IntegerVal 0,IntegerVal (-32768)]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s16(UINT64_C(0x33c480007fff0000));
      arg2 = vcreate_s16(UINT64_C(0x8000000000003741));
      clear_neon_saturated();
      //  Expect: "result" = 33c480007fff0000
      result = vqrshl_s16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s16(result), 0);
      exp = UINT64_C(0x33c480007fff0000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_900() {

{
   {
      int32x2_t arg1;
      int32x2_t arg2;
      int32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"qrshl\", fnname = \"vqrshl_s32\", rettype = \"int32x2_t\", argtypes = \"[int32x2_t,int32x2_t]\", vals = [VectorVal [IntegerVal 446070784,IntegerVal (-26764)],VectorVal [IntegerVal 0,IntegerVal 32768]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s32(UINT64_C(0xffff97741a968000));
      arg2 = vcreate_s32(UINT64_C(0x0000800000000000));
      clear_neon_saturated();
      //  Expect: "result" = ffff97741a968000
      result = vqrshl_s32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s32(result), 0);
      exp = UINT64_C(0xffff97741a968000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_901() {

{
   {
      int64x1_t arg1;
      int64x1_t arg2;
      int64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"qrshl\", fnname = \"vqrshl_s64\", rettype = \"int64x1_t\", argtypes = \"[int64x1_t,int64x1_t]\", vals = [VectorVal [IntegerVal (-9223231299366420481)],VectorVal [IntegerVal 140734111481856]], start_saturated = True}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s64(UINT64_C(0x80007fffffffffff));
      arg2 = vcreate_s64(UINT64_C(0x00007fff36b90000));
      set_neon_saturated();
      //  Expect: "result" = 80007fffffffffff
      result = vqrshl_s64(arg1, arg2);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s64(result), 0);
      exp = UINT64_C(0x80007fffffffffff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_902() {

{
   {
      uint8x8_t arg1;
      int8x8_t arg2;
      uint8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"qrshl\", fnname = \"vqrshl_u8\", rettype = \"uint8x8_t\", argtypes = \"[uint8x8_t,int8x8_t]\", vals = [VectorVal [IntegerVal 255,IntegerVal 128,IntegerVal 255,IntegerVal 0,IntegerVal 60,IntegerVal 128,IntegerVal 0,IntegerVal 128],VectorVal [IntegerVal 0,IntegerVal (-1),IntegerVal (-1),IntegerVal 0,IntegerVal 0,IntegerVal (-128),IntegerVal (-128),IntegerVal (-128)]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u8(UINT64_C(0x8000803c00ff80ff));
      arg2 = vcreate_s8(UINT64_C(0x8080800000ffff00));
      clear_neon_saturated();
      //  Expect: "result" = 0000003c008040ff
      result = vqrshl_u8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u8(result), 0);
      exp = UINT64_C(0x0000003c008040ff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_903() {

{
   {
      uint16x4_t arg1;
      int16x4_t arg2;
      uint16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"qrshl\", fnname = \"vqrshl_u16\", rettype = \"uint16x4_t\", argtypes = \"[uint16x4_t,int16x4_t]\", vals = [VectorVal [IntegerVal 32767,IntegerVal 65535,IntegerVal 65535,IntegerVal 32768],VectorVal [IntegerVal 0,IntegerVal (-1),IntegerVal 0,IntegerVal 32767]], start_saturated = True}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u16(UINT64_C(0x8000ffffffff7fff));
      arg2 = vcreate_s16(UINT64_C(0x7fff0000ffff0000));
      set_neon_saturated();
      //  Expect: "result" = 4000ffff80007fff
      result = vqrshl_u16(arg1, arg2);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u16(result), 0);
      exp = UINT64_C(0x4000ffff80007fff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_904() {

{
   {
      uint32x2_t arg1;
      int32x2_t arg2;
      uint32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"qrshl\", fnname = \"vqrshl_u32\", rettype = \"uint32x2_t\", argtypes = \"[uint32x2_t,int32x2_t]\", vals = [VectorVal [IntegerVal 2147450879,IntegerVal 37663],VectorVal [IntegerVal 32768,IntegerVal (-2147434951)]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u32(UINT64_C(0x0000931f7fff7fff));
      arg2 = vcreate_s32(UINT64_C(0x8000be3900008000));
      clear_neon_saturated();
      //  Expect: "result" = ffffffff7fff7fff
      result = vqrshl_u32(arg1, arg2);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u32(result), 0);
      exp = UINT64_C(0xffffffff7fff7fff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_905() {

{
   {
      uint64x1_t arg1;
      int64x1_t arg2;
      uint64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"qrshl\", fnname = \"vqrshl_u64\", rettype = \"uint64x1_t\", argtypes = \"[uint64x1_t,int64x1_t]\", vals = [VectorVal [IntegerVal 18446462598790545407],VectorVal [IntegerVal (-9223090561878097920)]], start_saturated = True}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u64(UINT64_C(0xffff000003707fff));
      arg2 = vcreate_s64(UINT64_C(0x8000ffffffff8000));
      set_neon_saturated();
      //  Expect: "result" = ffff000003707fff
      result = vqrshl_u64(arg1, arg2);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      got = vget_lane_u64(result, 0);
      exp = UINT64_C(0xffff000003707fff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_906() {

{
   {
      int8x16_t arg1;
      int8x16_t arg2;
      int8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"qrshl\", fnname = \"vqrshlq_s8\", rettype = \"int8x16_t\", argtypes = \"[int8x16_t,int8x16_t]\", vals = [VectorVal [IntegerVal (-1),IntegerVal 72,IntegerVal 127,IntegerVal 0,IntegerVal 122,IntegerVal 0,IntegerVal (-128),IntegerVal 127,IntegerVal (-1),IntegerVal 127,IntegerVal (-128),IntegerVal 0,IntegerVal (-25),IntegerVal 0,IntegerVal (-1),IntegerVal (-1)],VectorVal [IntegerVal (-86),IntegerVal 127,IntegerVal 50,IntegerVal (-128),IntegerVal (-128),IntegerVal 100,IntegerVal 0,IntegerVal (-128),IntegerVal 127,IntegerVal (-1),IntegerVal 127,IntegerVal (-128),IntegerVal 120,IntegerVal (-1),IntegerVal 127,IntegerVal (-1)]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s8(vcreate_s8(UINT64_C(0x7f80007a007f48ff)),
                         vcreate_s8(UINT64_C(0xffff00e700807fff)));
      arg2 = vcombine_s8(vcreate_s8(UINT64_C(0x8000648080327faa)),
                         vcreate_s8(UINT64_C(0xff7fff78807fff7f)));
      clear_neon_saturated();
      //  Expect: "result" = 008000800080408000800000007f7f00
      result = vqrshlq_s8(arg1, arg2);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result), 0);
         exp = UINT64_C(0x00800000007f7f00);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result), 1);
         exp = UINT64_C(0x0080008000804080);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_907() {

{
   {
      int16x8_t arg1;
      int16x8_t arg2;
      int16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"qrshl\", fnname = \"vqrshlq_s16\", rettype = \"int16x8_t\", argtypes = \"[int16x8_t,int16x8_t]\", vals = [VectorVal [IntegerVal 0,IntegerVal 21799,IntegerVal 0,IntegerVal 0,IntegerVal 32767,IntegerVal 0,IntegerVal (-32768),IntegerVal (-3457)],VectorVal [IntegerVal 32767,IntegerVal 0,IntegerVal (-32768),IntegerVal 0,IntegerVal 0,IntegerVal (-1),IntegerVal 32767,IntegerVal (-1)]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s16(vcreate_s16(UINT64_C(0x0000000055270000)),
                          vcreate_s16(UINT64_C(0xf27f800000007fff)));
      arg2 = vcombine_s16(vcreate_s16(UINT64_C(0x0000800000007fff)),
                          vcreate_s16(UINT64_C(0xffff7fffffff0000)));
      clear_neon_saturated();
      //  Expect: "result" = f940c00000007fff0000000055270000
      result = vqrshlq_s16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 0);
         exp = UINT64_C(0x0000000055270000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 1);
         exp = UINT64_C(0xf940c00000007fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_908() {

{
   {
      int32x4_t arg1;
      int32x4_t arg2;
      int32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"qrshl\", fnname = \"vqrshlq_s32\", rettype = \"int32x4_t\", argtypes = \"[int32x4_t,int32x4_t]\", vals = [VectorVal [IntegerVal (-560168961),IntegerVal (-2147421448),IntegerVal 1276641280,IntegerVal (-2147445436)],VectorVal [IntegerVal 45288,IntegerVal 2147467514,IntegerVal 65535,IntegerVal (-702644225)]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s32(vcreate_s32(UINT64_C(0x8000f2f8de9c7fff)),
                          vcreate_s32(UINT64_C(0x800095444c180000)));
      arg2 = vcombine_s32(vcreate_s32(UINT64_C(0x7fffc0fa0000b0e8)),
                          vcreate_s32(UINT64_C(0xd61e7fff0000ffff)));
      clear_neon_saturated();
      //  Expect: "result" = c0004aa2260c0000fe0003ccffffffdf
      result = vqrshlq_s32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 0);
         exp = UINT64_C(0xfe0003ccffffffdf);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 1);
         exp = UINT64_C(0xc0004aa2260c0000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_909() {

{
   {
      int64x2_t arg1;
      int64x2_t arg2;
      int64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"qrshl\", fnname = \"vqrshlq_s64\", rettype = \"int64x2_t\", argtypes = \"[int64x2_t,int64x2_t]\", vals = [VectorVal [IntegerVal (-140737488309757),IntegerVal 4792955901023584255],VectorVal [IntegerVal 3691033065980723200,IntegerVal 9223090564085219328]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s64(vcreate_s64(UINT64_C(0xffff80000000b203)),
                          vcreate_s64(UINT64_C(0x4283ffff709f7fff)));
      arg2 = vcombine_s64(vcreate_s64(UINT64_C(0x33392f0480008000)),
                          vcreate_s64(UINT64_C(0x7fff0000838e8000)));
      clear_neon_saturated();
      //  Expect: "result" = 4283ffff709f7fffffff80000000b203
      result = vqrshlq_s64(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 0);
         exp = UINT64_C(0xffff80000000b203);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 1);
         exp = UINT64_C(0x4283ffff709f7fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_910() {

{
   {
      uint8x16_t arg1;
      int8x16_t arg2;
      uint8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"qrshl\", fnname = \"vqrshlq_u8\", rettype = \"uint8x16_t\", argtypes = \"[uint8x16_t,int8x16_t]\", vals = [VectorVal [IntegerVal 255,IntegerVal 127,IntegerVal 127,IntegerVal 255,IntegerVal 255,IntegerVal 128,IntegerVal 128,IntegerVal 19,IntegerVal 0,IntegerVal 128,IntegerVal 255,IntegerVal 127,IntegerVal 128,IntegerVal 255,IntegerVal 0,IntegerVal 130],VectorVal [IntegerVal (-128),IntegerVal 107,IntegerVal (-1),IntegerVal (-128),IntegerVal 0,IntegerVal (-128),IntegerVal (-128),IntegerVal (-128),IntegerVal (-1),IntegerVal (-101),IntegerVal 24,IntegerVal (-36),IntegerVal (-23),IntegerVal (-1),IntegerVal 127,IntegerVal 127]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u8(vcreate_u8(UINT64_C(0x138080ffff7f7fff)),
                         vcreate_u8(UINT64_C(0x8200ff807fff8000)));
      arg2 = vcombine_s8(vcreate_s8(UINT64_C(0x8080800080ff6b80)),
                         vcreate_s8(UINT64_C(0x7f7fffe9dc189bff)));
      clear_neon_saturated();
      //  Expect: "result" = ff00800000ff0000000000ff0040ff00
      result = vqrshlq_u8(arg1, arg2);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 0);
         exp = UINT64_C(0x000000ff0040ff00);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 1);
         exp = UINT64_C(0xff00800000ff0000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_911() {

{
   {
      uint16x8_t arg1;
      int16x8_t arg2;
      uint16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"qrshl\", fnname = \"vqrshlq_u16\", rettype = \"uint16x8_t\", argtypes = \"[uint16x8_t,int16x8_t]\", vals = [VectorVal [IntegerVal 32767,IntegerVal 65535,IntegerVal 42772,IntegerVal 32767,IntegerVal 18405,IntegerVal 32768,IntegerVal 56082,IntegerVal 32767],VectorVal [IntegerVal 28397,IntegerVal 32767,IntegerVal (-19541),IntegerVal (-32768),IntegerVal 32767,IntegerVal 32767,IntegerVal 21014,IntegerVal 32767]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u16(vcreate_u16(UINT64_C(0x7fffa714ffff7fff)),
                          vcreate_u16(UINT64_C(0x7fffdb12800047e5)));
      arg2 = vcombine_s16(vcreate_s16(UINT64_C(0x8000b3ab7fff6eed)),
                          vcreate_s16(UINT64_C(0x7fff52167fff7fff)));
      clear_neon_saturated();
      //  Expect: "result" = 4000ffff400023f37fff000080000000
      result = vqrshlq_u16(arg1, arg2);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 0);
         exp = UINT64_C(0x7fff000080000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 1);
         exp = UINT64_C(0x4000ffff400023f3);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_912() {

{
   {
      uint32x4_t arg1;
      int32x4_t arg2;
      uint32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"qrshl\", fnname = \"vqrshlq_u32\", rettype = \"uint32x4_t\", argtypes = \"[uint32x4_t,int32x4_t]\", vals = [VectorVal [IntegerVal 30605311,IntegerVal 2147450879,IntegerVal 906395647,IntegerVal 32768],VectorVal [IntegerVal 2147418112,IntegerVal (-1),IntegerVal (-65536),IntegerVal (-2147472107)]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u32(vcreate_u32(UINT64_C(0x7fff7fff01d2ffff)),
                          vcreate_u32(UINT64_C(0x0000800036067fff)));
      arg2 = vcombine_s32(vcreate_s32(UINT64_C(0xffffffff7fff0000)),
                          vcreate_s32(UINT64_C(0x80002d15ffff0000)));
      clear_neon_saturated();
      //  Expect: "result" = ffffffff36067fff3fffc00001d2ffff
      result = vqrshlq_u32(arg1, arg2);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 0);
         exp = UINT64_C(0x3fffc00001d2ffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 1);
         exp = UINT64_C(0xffffffff36067fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_913() {

{
   {
      uint64x2_t arg1;
      int64x2_t arg2;
      uint64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"qrshl\", fnname = \"vqrshlq_u64\", rettype = \"uint64x2_t\", argtypes = \"[uint64x2_t,int64x2_t]\", vals = [VectorVal [IntegerVal 9223231297218904063,IntegerVal 281472829259776],VectorVal [IntegerVal 9223325105747147235,IntegerVal (-9223231298243395584)]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u64(vcreate_u64(UINT64_C(0x7fff7fff7fff7fff)),
                          vcreate_u64(UINT64_C(0x0000ffff80008000)));
      arg2 = vcombine_s64(vcreate_s64(UINT64_C(0x7fffd551000039e3)),
                          vcreate_s64(UINT64_C(0x8000800042f00000)));
      clear_neon_saturated();
      //  Expect: "result" = 0000ffff8000800000000003fffbfffc
      result = vqrshlq_u64(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 0);
         exp = UINT64_C(0x00000003fffbfffc);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 1);
         exp = UINT64_C(0x0000ffff80008000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_914() {

{
   {
      int8_t arg1;
      int8_t arg2;
      int8_t result;
      char* str1 = "ReproInfo2 {semantics = \"qrshl\", fnname = \"vqrshlb_s8\", rettype = \"int8_t\", argtypes = \"[int8_t,int8_t]\", vals = [IntegerVal (-1),IntegerVal (-1)], start_saturated = False}";
      int reported = 0;
      int8_t got;
      int8_t exp;
      arg1 = -1;
      arg2 = -1;
      clear_neon_saturated();
      //  Expect: "result" = 00
      result = vqrshlb_s8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = 0;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_915() {

{
   {
      int16_t arg1;
      int16_t arg2;
      int16_t result;
      char* str1 = "ReproInfo2 {semantics = \"qrshl\", fnname = \"vqrshlh_s16\", rettype = \"int16_t\", argtypes = \"[int16_t,int16_t]\", vals = [IntegerVal (-19723),IntegerVal 32767], start_saturated = False}";
      int reported = 0;
      int16_t got;
      int16_t exp;
      arg1 = -19723;
      arg2 = 32767;
      clear_neon_saturated();
      //  Expect: "result" = d97b
      result = vqrshlh_s16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = -9861;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIi16 " Got: %" PRIi16 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_916() {

{
   {
      int32_t arg1;
      int32_t arg2;
      int32_t result;
      char* str1 = "ReproInfo2 {semantics = \"qrshl\", fnname = \"vqrshls_s32\", rettype = \"int32_t\", argtypes = \"[int32_t,int32_t]\", vals = [IntegerVal 32767,IntegerVal 2147450879], start_saturated = False}";
      int reported = 0;
      int32_t got;
      int32_t exp;
      arg1 = 32767;
      arg2 = 2147450879;
      clear_neon_saturated();
      //  Expect: "result" = 00004000
      result = vqrshls_s32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = 16384;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIi32 " Got: %" PRIi32 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_917() {

{
   {
      int64_t arg1;
      int64_t arg2;
      int64_t result;
      char* str1 = "ReproInfo2 {semantics = \"qrshl\", fnname = \"vqrshld_s64\", rettype = \"int64_t\", argtypes = \"[int64_t,int64_t]\", vals = [IntegerVal 18884971167744,IntegerVal 2147549183], start_saturated = False}";
      int reported = 0;
      int64_t got;
      int64_t exp;
      arg1 = INT64_C(18884971167744);
      arg2 = INT64_C(2147549183);
      clear_neon_saturated();
      //  Expect: "result" = 000008967fffc000
      result = vqrshld_s64(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = INT64_C(9442485583872);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIi64 " Got: %" PRIi64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_918() {

{
   {
      uint8_t arg1;
      int8_t arg2;
      uint8_t result;
      char* str1 = "ReproInfo2 {semantics = \"qrshl\", fnname = \"vqrshlb_u8\", rettype = \"uint8_t\", argtypes = \"[uint8_t,int8_t]\", vals = [IntegerVal 128,IntegerVal (-1)], start_saturated = False}";
      int reported = 0;
      uint8_t got;
      uint8_t exp;
      arg1 = 128U;
      arg2 = -1;
      clear_neon_saturated();
      //  Expect: "result" = 40
      result = vqrshlb_u8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = 64U;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_919() {

{
   {
      uint16_t arg1;
      int16_t arg2;
      uint16_t result;
      char* str1 = "ReproInfo2 {semantics = \"qrshl\", fnname = \"vqrshlh_u16\", rettype = \"uint16_t\", argtypes = \"[uint16_t,int16_t]\", vals = [IntegerVal 32768,IntegerVal (-1)], start_saturated = False}";
      int reported = 0;
      uint16_t got;
      uint16_t exp;
      arg1 = 32768U;
      arg2 = -1;
      clear_neon_saturated();
      //  Expect: "result" = 4000
      result = vqrshlh_u16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = 16384U;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_920() {

{
   {
      uint32_t arg1;
      int32_t arg2;
      uint32_t result;
      char* str1 = "ReproInfo2 {semantics = \"qrshl\", fnname = \"vqrshls_u32\", rettype = \"uint32_t\", argtypes = \"[uint32_t,int32_t]\", vals = [IntegerVal 3714970649,IntegerVal 2147418112], start_saturated = False}";
      int reported = 0;
      uint32_t got;
      uint32_t exp;
      arg1 = 3714970649U;
      arg2 = 2147418112;
      clear_neon_saturated();
      //  Expect: "result" = dd6df419
      result = vqrshls_u32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = 3714970649U;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIu32 " Got: %" PRIu32 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_921() {

{
   {
      uint64_t arg1;
      int64_t arg2;
      uint64_t result;
      char* str1 = "ReproInfo2 {semantics = \"qrshl\", fnname = \"vqrshld_u64\", rettype = \"uint64_t\", argtypes = \"[uint64_t,int64_t]\", vals = [IntegerVal 140735340871679,IntegerVal (-2711307717460328449)], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = UINT64_C(0x00007fff7fffffff);
      arg2 = INT64_C(-2711307717460328449);
      clear_neon_saturated();
      //  Expect: "result" = 00003fffc0000000
      result = vqrshld_u64(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = UINT64_C(0x00003fffc0000000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_922() {

{
   {
      int8x8_t arg1;
      int8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"shr\", fnname = \"vshr_n_s8\", rettype = \"int8x8_t\", argtypes = \"[int8x8_t,__constrange(1,8) int]\", vals = [VectorVal [IntegerVal 67,IntegerVal 0,IntegerVal 75,IntegerVal (-49),IntegerVal (-128),IntegerVal 0,IntegerVal (-1),IntegerVal 127],IndexVal 5], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s8(UINT64_C(0x7fff0080cf4b0043));
      clear_neon_saturated();
      //  Expect: "result" = 03ff00fcfe020002
      result = vshr_n_s8(arg1, 5);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s8(result), 0);
      exp = UINT64_C(0x03ff00fcfe020002);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_923() {

{
   {
      int16x4_t arg1;
      int16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"shr\", fnname = \"vshr_n_s16\", rettype = \"int16x4_t\", argtypes = \"[int16x4_t,__constrange(1,16) int]\", vals = [VectorVal [IntegerVal (-1),IntegerVal (-32768),IntegerVal (-1),IntegerVal 32767],IndexVal 9], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s16(UINT64_C(0x7fffffff8000ffff));
      clear_neon_saturated();
      //  Expect: "result" = 003fffffffc0ffff
      result = vshr_n_s16(arg1, 9);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s16(result), 0);
      exp = UINT64_C(0x003fffffffc0ffff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_924() {

{
   {
      int32x2_t arg1;
      int32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"shr\", fnname = \"vshr_n_s32\", rettype = \"int32x2_t\", argtypes = \"[int32x2_t,__constrange(1,32) int]\", vals = [VectorVal [IntegerVal 32767,IntegerVal 2147450879],IndexVal 21], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s32(UINT64_C(0x7fff7fff00007fff));
      clear_neon_saturated();
      //  Expect: "result" = 000003ff00000000
      result = vshr_n_s32(arg1, 21);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s32(result), 0);
      exp = UINT64_C(0x000003ff00000000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_925() {

{
   {
      int64x1_t arg1;
      int64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"shr\", fnname = \"vshr_n_s64\", rettype = \"int64x1_t\", argtypes = \"[int64x1_t,__constrange(1,64) int]\", vals = [VectorVal [IntegerVal 9223090561878097920],IndexVal 58], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s64(UINT64_C(0x7fff000000008000));
      clear_neon_saturated();
      //  Expect: "result" = 000000000000001f
      result = vshr_n_s64(arg1, 58);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s64(result), 0);
      exp = UINT64_C(0x000000000000001f);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_926() {

{
   {
      uint8x8_t arg1;
      uint8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"shr\", fnname = \"vshr_n_u8\", rettype = \"uint8x8_t\", argtypes = \"[uint8x8_t,__constrange(1,8) int]\", vals = [VectorVal [IntegerVal 128,IntegerVal 128,IntegerVal 217,IntegerVal 106,IntegerVal 128,IntegerVal 129,IntegerVal 245,IntegerVal 255],IndexVal 2], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u8(UINT64_C(0xfff581806ad98080));
      clear_neon_saturated();
      //  Expect: "result" = 3f3d20201a362020
      result = vshr_n_u8(arg1, 2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u8(result), 0);
      exp = UINT64_C(0x3f3d20201a362020);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_927() {

{
   {
      uint16x4_t arg1;
      uint16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"shr\", fnname = \"vshr_n_u16\", rettype = \"uint16x4_t\", argtypes = \"[uint16x4_t,__constrange(1,16) int]\", vals = [VectorVal [IntegerVal 55004,IntegerVal 0,IntegerVal 32767,IntegerVal 32768],IndexVal 7], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u16(UINT64_C(0x80007fff0000d6dc));
      clear_neon_saturated();
      //  Expect: "result" = 010000ff000001ad
      result = vshr_n_u16(arg1, 7);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u16(result), 0);
      exp = UINT64_C(0x010000ff000001ad);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_928() {

{
   {
      uint32x2_t arg1;
      uint32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"shr\", fnname = \"vshr_n_u32\", rettype = \"uint32x2_t\", argtypes = \"[uint32x2_t,__constrange(1,32) int]\", vals = [VectorVal [IntegerVal 4294934527,IntegerVal 11182],IndexVal 17], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u32(UINT64_C(0x00002baeffff7fff));
      clear_neon_saturated();
      //  Expect: "result" = 0000000000007fff
      result = vshr_n_u32(arg1, 17);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u32(result), 0);
      exp = UINT64_C(0x0000000000007fff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_929() {

{
   {
      uint64x1_t arg1;
      uint64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"shr\", fnname = \"vshr_n_u64\", rettype = \"uint64x1_t\", argtypes = \"[uint64x1_t,__constrange(1,64) int]\", vals = [VectorVal [IntegerVal 18446603338368679936],IndexVal 35], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u64(UINT64_C(0xffff800080000000));
      clear_neon_saturated();
      //  Expect: "result" = 000000001ffff000
      result = vshr_n_u64(arg1, 35);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(result, 0);
      exp = UINT64_C(0x000000001ffff000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_930() {

{
   {
      int8x16_t arg1;
      int8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"shr\", fnname = \"vshrq_n_s8\", rettype = \"int8x16_t\", argtypes = \"[int8x16_t,__constrange(1,8) int]\", vals = [VectorVal [IntegerVal 0,IntegerVal 127,IntegerVal 127,IntegerVal (-81),IntegerVal 127,IntegerVal (-128),IntegerVal 127,IntegerVal (-1),IntegerVal (-128),IntegerVal 127,IntegerVal (-94),IntegerVal 127,IntegerVal 127,IntegerVal (-1),IntegerVal 0,IntegerVal (-93)],IndexVal 3], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s8(vcreate_s8(UINT64_C(0xff7f807faf7f7f00)),
                         vcreate_s8(UINT64_C(0xa300ff7f7fa27f80)));
      clear_neon_saturated();
      //  Expect: "result" = f400ff0f0ff40ff0ff0ff00ff50f0f00
      result = vshrq_n_s8(arg1, 3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result), 0);
         exp = UINT64_C(0xff0ff00ff50f0f00);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result), 1);
         exp = UINT64_C(0xf400ff0f0ff40ff0);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_931() {

{
   {
      int16x8_t arg1;
      int16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"shr\", fnname = \"vshrq_n_s16\", rettype = \"int16x8_t\", argtypes = \"[int16x8_t,__constrange(1,16) int]\", vals = [VectorVal [IntegerVal 0,IntegerVal (-1),IntegerVal 32767,IntegerVal 0,IntegerVal 0,IntegerVal (-32768),IntegerVal (-1),IntegerVal (-17878)],IndexVal 13], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s16(vcreate_s16(UINT64_C(0x00007fffffff0000)),
                          vcreate_s16(UINT64_C(0xba2affff80000000)));
      clear_neon_saturated();
      //  Expect: "result" = fffdfffffffc000000000003ffff0000
      result = vshrq_n_s16(arg1, 13);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 0);
         exp = UINT64_C(0x00000003ffff0000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 1);
         exp = UINT64_C(0xfffdfffffffc0000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_932() {

{
   {
      int32x4_t arg1;
      int32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"shr\", fnname = \"vshrq_n_s32\", rettype = \"int32x4_t\", argtypes = \"[int32x4_t,__constrange(1,32) int]\", vals = [VectorVal [IntegerVal 2147418112,IntegerVal 2147418112,IntegerVal (-2147418113),IntegerVal 623962645],IndexVal 22], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s32(vcreate_s32(UINT64_C(0x7fff00007fff0000)),
                          vcreate_s32(UINT64_C(0x2530ea158000ffff)));
      clear_neon_saturated();
      //  Expect: "result" = 00000094fffffe00000001ff000001ff
      result = vshrq_n_s32(arg1, 22);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 0);
         exp = UINT64_C(0x000001ff000001ff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 1);
         exp = UINT64_C(0x00000094fffffe00);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_933() {

{
   {
      int64x2_t arg1;
      int64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"shr\", fnname = \"vshrq_n_s64\", rettype = \"int64x2_t\", argtypes = \"[int64x2_t,__constrange(1,64) int]\", vals = [VectorVal [IntegerVal 9223285551245802645,IntegerVal (-9223231298712895488)],IndexVal 53], start_saturated = True}";
      int reported = 0;
      arg1 = vcombine_s64(vcreate_s64(UINT64_C(0x7fffb1577fffbc95)),
                          vcreate_s64(UINT64_C(0x8000800026f40000)));
      set_neon_saturated();
      //  Expect: "result" = fffffffffffffc0000000000000003ff
      result = vshrq_n_s64(arg1, 53);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 0);
         exp = UINT64_C(0x00000000000003ff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 1);
         exp = UINT64_C(0xfffffffffffffc00);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_934() {

{
   {
      uint8x16_t arg1;
      uint8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"shr\", fnname = \"vshrq_n_u8\", rettype = \"uint8x16_t\", argtypes = \"[uint8x16_t,__constrange(1,8) int]\", vals = [VectorVal [IntegerVal 0,IntegerVal 128,IntegerVal 128,IntegerVal 255,IntegerVal 255,IntegerVal 128,IntegerVal 255,IntegerVal 13,IntegerVal 127,IntegerVal 255,IntegerVal 228,IntegerVal 128,IntegerVal 128,IntegerVal 128,IntegerVal 0,IntegerVal 0],IndexVal 6], start_saturated = True}";
      int reported = 0;
      arg1 = vcombine_u8(vcreate_u8(UINT64_C(0x0dff80ffff808000)),
                         vcreate_u8(UINT64_C(0x0000808080e4ff7f)));
      set_neon_saturated();
      //  Expect: "result" = 00000202020303010003020303020200
      result = vshrq_n_u8(arg1, 6);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 0);
         exp = UINT64_C(0x0003020303020200);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 1);
         exp = UINT64_C(0x0000020202030301);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_935() {

{
   {
      uint16x8_t arg1;
      uint16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"shr\", fnname = \"vshrq_n_u16\", rettype = \"uint16x8_t\", argtypes = \"[uint16x8_t,__constrange(1,16) int]\", vals = [VectorVal [IntegerVal 65535,IntegerVal 32767,IntegerVal 32768,IntegerVal 32768,IntegerVal 32768,IntegerVal 65535,IntegerVal 32767,IntegerVal 65535],IndexVal 3], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u16(vcreate_u16(UINT64_C(0x800080007fffffff)),
                          vcreate_u16(UINT64_C(0xffff7fffffff8000)));
      clear_neon_saturated();
      //  Expect: "result" = 1fff0fff1fff1000100010000fff1fff
      result = vshrq_n_u16(arg1, 3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 0);
         exp = UINT64_C(0x100010000fff1fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 1);
         exp = UINT64_C(0x1fff0fff1fff1000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_936() {

{
   {
      uint32x4_t arg1;
      uint32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"shr\", fnname = \"vshrq_n_u32\", rettype = \"uint32x4_t\", argtypes = \"[uint32x4_t,__constrange(1,32) int]\", vals = [VectorVal [IntegerVal 4294967295,IntegerVal 3702063104,IntegerVal 4294934527,IntegerVal 2147516416],IndexVal 18], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u32(vcreate_u32(UINT64_C(0xdca90000ffffffff)),
                          vcreate_u32(UINT64_C(0x80008000ffff7fff)));
      clear_neon_saturated();
      //  Expect: "result" = 0000200000003fff0000372a00003fff
      result = vshrq_n_u32(arg1, 18);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 0);
         exp = UINT64_C(0x0000372a00003fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 1);
         exp = UINT64_C(0x0000200000003fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_937() {

{
   {
      uint64x2_t arg1;
      uint64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"shr\", fnname = \"vshrq_n_u64\", rettype = \"uint64x2_t\", argtypes = \"[uint64x2_t,__constrange(1,64) int]\", vals = [VectorVal [IntegerVal 9223512772195647487,IntegerVal 140739659104256],IndexVal 46], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u64(vcreate_u64(UINT64_C(0x80007fff7fffffff)),
                          vcreate_u64(UINT64_C(0x0000800081630000)));
      clear_neon_saturated();
      //  Expect: "result" = 00000000000000020000000000020001
      result = vshrq_n_u64(arg1, 46);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 0);
         exp = UINT64_C(0x0000000000020001);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 1);
         exp = UINT64_C(0x0000000000000002);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_938() {

{
   {
      int64_t arg1;
      int64_t result;
      char* str1 = "ReproInfo2 {semantics = \"shr\", fnname = \"vshrd_n_s64\", rettype = \"int64_t\", argtypes = \"[int64_t,__constrange(1,64) int]\", vals = [IntegerVal (-140737488386494),IndexVal 22], start_saturated = False}";
      int reported = 0;
      int64_t got;
      int64_t exp;
      arg1 = INT64_C(-140737488386494);
      clear_neon_saturated();
      //  Expect: "result" = fffffffffdffffff
      result = vshrd_n_s64(arg1, 22);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = INT64_C(-33554433);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIi64 " Got: %" PRIi64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_939() {

{
   {
      uint64_t arg1;
      uint64_t result;
      char* str1 = "ReproInfo2 {semantics = \"shr\", fnname = \"vshrd_n_u64\", rettype = \"uint64_t\", argtypes = \"[uint64_t,__constrange(1,64) int]\", vals = [IntegerVal 18446603340516098048,IndexVal 13], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = UINT64_C(0xffff8000ffff0000);
      clear_neon_saturated();
      //  Expect: "result" = 0007fffc0007fff8
      result = vshrd_n_u64(arg1, 13);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = UINT64_C(0x0007fffc0007fff8);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_940() {

{
   {
      int8x8_t arg1;
      int8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"shl\", fnname = \"vshl_n_s8\", rettype = \"int8x8_t\", argtypes = \"[int8x8_t,__constrange(0,7) int]\", vals = [VectorVal [IntegerVal 107,IntegerVal (-85),IntegerVal (-128),IntegerVal (-128),IntegerVal 127,IntegerVal (-128),IntegerVal 0,IntegerVal (-1)],IndexVal 5], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s8(UINT64_C(0xff00807f8080ab6b));
      clear_neon_saturated();
      //  Expect: "result" = e00000e000006060
      result = vshl_n_s8(arg1, 5);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s8(result), 0);
      exp = UINT64_C(0xe00000e000006060);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_941() {

{
   {
      int16x4_t arg1;
      int16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"shl\", fnname = \"vshl_n_s16\", rettype = \"int16x4_t\", argtypes = \"[int16x4_t,__constrange(0,15) int]\", vals = [VectorVal [IntegerVal (-1),IntegerVal (-32768),IntegerVal (-15214),IntegerVal 32767],IndexVal 11], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s16(UINT64_C(0x7fffc4928000ffff));
      clear_neon_saturated();
      //  Expect: "result" = f80090000000f800
      result = vshl_n_s16(arg1, 11);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s16(result), 0);
      exp = UINT64_C(0xf80090000000f800);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_942() {

{
   {
      int32x2_t arg1;
      int32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"shl\", fnname = \"vshl_n_s32\", rettype = \"int32x2_t\", argtypes = \"[int32x2_t,__constrange(0,31) int]\", vals = [VectorVal [IntegerVal 2147450880,IntegerVal 2147450880],IndexVal 18], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s32(UINT64_C(0x7fff80007fff8000));
      clear_neon_saturated();
      //  Expect: "result" = 0000000000000000
      result = vshl_n_s32(arg1, 18);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s32(result), 0);
      exp = 0;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_943() {

{
   {
      int64x1_t arg1;
      int64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"shl\", fnname = \"vshl_n_s64\", rettype = \"int64x1_t\", argtypes = \"[int64x1_t,__constrange(0,63) int]\", vals = [VectorVal [IntegerVal 281472829195406],IndexVal 20], start_saturated = True}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s64(UINT64_C(0x0000ffff7fff848e));
      set_neon_saturated();
      //  Expect: "result" = fff7fff848e00000
      result = vshl_n_s64(arg1, 20);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s64(result), 0);
      exp = UINT64_C(0xfff7fff848e00000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_944() {

{
   {
      uint8x8_t arg1;
      uint8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"shl\", fnname = \"vshl_n_u8\", rettype = \"uint8x8_t\", argtypes = \"[uint8x8_t,__constrange(0,7) int]\", vals = [VectorVal [IntegerVal 0,IntegerVal 42,IntegerVal 127,IntegerVal 0,IntegerVal 255,IntegerVal 255,IntegerVal 128,IntegerVal 128],IndexVal 0], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u8(UINT64_C(0x8080ffff007f2a00));
      clear_neon_saturated();
      //  Expect: "result" = 8080ffff007f2a00
      result = vshl_n_u8(arg1, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u8(result), 0);
      exp = UINT64_C(0x8080ffff007f2a00);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_945() {

{
   {
      uint16x4_t arg1;
      uint16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"shl\", fnname = \"vshl_n_u16\", rettype = \"uint16x4_t\", argtypes = \"[uint16x4_t,__constrange(0,15) int]\", vals = [VectorVal [IntegerVal 29612,IntegerVal 32768,IntegerVal 65535,IntegerVal 0],IndexVal 4], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u16(UINT64_C(0x0000ffff800073ac));
      clear_neon_saturated();
      //  Expect: "result" = 0000fff000003ac0
      result = vshl_n_u16(arg1, 4);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u16(result), 0);
      exp = UINT64_C(0x0000fff000003ac0);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_946() {

{
   {
      uint32x2_t arg1;
      uint32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"shl\", fnname = \"vshl_n_u32\", rettype = \"uint32x2_t\", argtypes = \"[uint32x2_t,__constrange(0,31) int]\", vals = [VectorVal [IntegerVal 2147450879,IntegerVal 1646526464],IndexVal 1], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u32(UINT64_C(0x622400007fff7fff));
      clear_neon_saturated();
      //  Expect: "result" = c4480000fffefffe
      result = vshl_n_u32(arg1, 1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u32(result), 0);
      exp = UINT64_C(0xc4480000fffefffe);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_947() {

{
   {
      uint64x1_t arg1;
      uint64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"shl\", fnname = \"vshl_n_u64\", rettype = \"uint64x1_t\", argtypes = \"[uint64x1_t,__constrange(0,63) int]\", vals = [VectorVal [IntegerVal 9223372032559808512],IndexVal 15], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u64(UINT64_C(0x7fffffff00000000));
      clear_neon_saturated();
      //  Expect: "result" = ffff800000000000
      result = vshl_n_u64(arg1, 15);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(result, 0);
      exp = UINT64_C(0xffff800000000000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_948() {

{
   {
      int8x16_t arg1;
      int8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"shl\", fnname = \"vshlq_n_s8\", rettype = \"int8x16_t\", argtypes = \"[int8x16_t,__constrange(0,7) int]\", vals = [VectorVal [IntegerVal 32,IntegerVal (-1),IntegerVal 0,IntegerVal (-128),IntegerVal (-14),IntegerVal (-128),IntegerVal 0,IntegerVal (-1),IntegerVal (-128),IntegerVal (-128),IntegerVal 127,IntegerVal (-128),IntegerVal (-128),IntegerVal (-84),IntegerVal 127,IntegerVal (-1)],IndexVal 6], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s8(vcreate_s8(UINT64_C(0xff0080f28000ff20)),
                         vcreate_s8(UINT64_C(0xff7fac80807f8080)));
      clear_neon_saturated();
      //  Expect: "result" = c0c0000000c00000c00000800000c000
      result = vshlq_n_s8(arg1, 6);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result), 0);
         exp = UINT64_C(0xc00000800000c000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result), 1);
         exp = UINT64_C(0xc0c0000000c00000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_949() {

{
   {
      int16x8_t arg1;
      int16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"shl\", fnname = \"vshlq_n_s16\", rettype = \"int16x8_t\", argtypes = \"[int16x8_t,__constrange(0,15) int]\", vals = [VectorVal [IntegerVal (-1),IntegerVal (-1),IntegerVal 0,IntegerVal 0,IntegerVal 32767,IntegerVal 32767,IntegerVal 32767,IntegerVal 0],IndexVal 0], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s16(vcreate_s16(UINT64_C(0x00000000ffffffff)),
                          vcreate_s16(UINT64_C(0x00007fff7fff7fff)));
      clear_neon_saturated();
      //  Expect: "result" = 00007fff7fff7fff00000000ffffffff
      result = vshlq_n_s16(arg1, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 0);
         exp = UINT64_C(0x00000000ffffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 1);
         exp = UINT64_C(0x00007fff7fff7fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_950() {

{
   {
      int32x4_t arg1;
      int32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"shl\", fnname = \"vshlq_n_s32\", rettype = \"int32x4_t\", argtypes = \"[int32x4_t,__constrange(0,31) int]\", vals = [VectorVal [IntegerVal (-2147450881),IntegerVal 32768,IntegerVal 1559756799,IntegerVal 155779072],IndexVal 24], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s32(vcreate_s32(UINT64_C(0x0000800080007fff)),
                          vcreate_s32(UINT64_C(0x094900005cf7ffff)));
      clear_neon_saturated();
      //  Expect: "result" = 00000000ff00000000000000ff000000
      result = vshlq_n_s32(arg1, 24);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 0);
         exp = UINT64_C(0x00000000ff000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 1);
         exp = UINT64_C(0x00000000ff000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_951() {

{
   {
      int64x2_t arg1;
      int64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"shl\", fnname = \"vshlq_n_s64\", rettype = \"int64x2_t\", argtypes = \"[int64x2_t,__constrange(0,63) int]\", vals = [VectorVal [IntegerVal (-8612472572841000961),IntegerVal (-9223231301513838593)],IndexVal 58], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s64(vcreate_s64(UINT64_C(0x887a59d36a047fff)),
                          vcreate_s64(UINT64_C(0x80007fff8000ffff)));
      clear_neon_saturated();
      //  Expect: "result" = fc00000000000000fc00000000000000
      result = vshlq_n_s64(arg1, 58);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 0);
         exp = UINT64_C(0xfc00000000000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 1);
         exp = UINT64_C(0xfc00000000000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_952() {

{
   {
      uint8x16_t arg1;
      uint8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"shl\", fnname = \"vshlq_n_u8\", rettype = \"uint8x16_t\", argtypes = \"[uint8x16_t,__constrange(0,7) int]\", vals = [VectorVal [IntegerVal 255,IntegerVal 54,IntegerVal 128,IntegerVal 255,IntegerVal 127,IntegerVal 0,IntegerVal 243,IntegerVal 127,IntegerVal 128,IntegerVal 108,IntegerVal 128,IntegerVal 0,IntegerVal 128,IntegerVal 128,IntegerVal 255,IntegerVal 127],IndexVal 4], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u8(vcreate_u8(UINT64_C(0x7ff3007fff8036ff)),
                         vcreate_u8(UINT64_C(0x7fff808000806c80)));
      clear_neon_saturated();
      //  Expect: "result" = f0f000000000c000f03000f0f00060f0
      result = vshlq_n_u8(arg1, 4);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 0);
         exp = UINT64_C(0xf03000f0f00060f0);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 1);
         exp = UINT64_C(0xf0f000000000c000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_953() {

{
   {
      uint16x8_t arg1;
      uint16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"shl\", fnname = \"vshlq_n_u16\", rettype = \"uint16x8_t\", argtypes = \"[uint16x8_t,__constrange(0,15) int]\", vals = [VectorVal [IntegerVal 0,IntegerVal 32768,IntegerVal 32767,IntegerVal 32768,IntegerVal 32768,IntegerVal 32767,IntegerVal 0,IntegerVal 17820],IndexVal 15], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u16(vcreate_u16(UINT64_C(0x80007fff80000000)),
                          vcreate_u16(UINT64_C(0x459c00007fff8000)));
      clear_neon_saturated();
      //  Expect: "result" = 00000000800000000000800000000000
      result = vshlq_n_u16(arg1, 15);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 0);
         exp = UINT64_C(0x0000800000000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 1);
         exp = UINT64_C(0x0000000080000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_954() {

{
   {
      uint32x4_t arg1;
      uint32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"shl\", fnname = \"vshlq_n_u32\", rettype = \"uint32x4_t\", argtypes = \"[uint32x4_t,__constrange(0,31) int]\", vals = [VectorVal [IntegerVal 2147450880,IntegerVal 2997583872,IntegerVal 2294611968,IntegerVal 0],IndexVal 4], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u32(vcreate_u32(UINT64_C(0xb2ab80007fff8000)),
                          vcreate_u32(UINT64_C(0x0000000088c50000)));
      clear_neon_saturated();
      //  Expect: "result" = 000000008c5000002ab80000fff80000
      result = vshlq_n_u32(arg1, 4);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 0);
         exp = UINT64_C(0x2ab80000fff80000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 1);
         exp = UINT64_C(0x000000008c500000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_955() {

{
   {
      uint64x2_t arg1;
      uint64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"shl\", fnname = \"vshlq_n_u64\", rettype = \"uint64x2_t\", argtypes = \"[uint64x2_t,__constrange(0,63) int]\", vals = [VectorVal [IntegerVal 9223231297218969599,IntegerVal 9223231303661332170],IndexVal 23], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u64(vcreate_u64(UINT64_C(0x7fff7fff80007fff)),
                          vcreate_u64(UINT64_C(0x7fff8000ffff26ca)));
      clear_neon_saturated();
      //  Expect: "result" = 007fff9365000000ffc0003fff800000
      result = vshlq_n_u64(arg1, 23);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 0);
         exp = UINT64_C(0xffc0003fff800000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 1);
         exp = UINT64_C(0x007fff9365000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_956() {

{
   {
      int64_t arg1;
      int64_t result;
      char* str1 = "ReproInfo2 {semantics = \"shl\", fnname = \"vshld_n_s64\", rettype = \"int64_t\", argtypes = \"[int64_t,__constrange(0,63) int]\", vals = [IntegerVal (-7389281090755624961),IndexVal 57], start_saturated = False}";
      int reported = 0;
      int64_t got;
      int64_t exp;
      arg1 = INT64_C(-7389281090755624961);
      clear_neon_saturated();
      //  Expect: "result" = fe00000000000000
      result = vshld_n_s64(arg1, 57);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = INT64_C(-144115188075855872);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIi64 " Got: %" PRIi64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_957() {

{
   {
      uint64_t arg1;
      uint64_t result;
      char* str1 = "ReproInfo2 {semantics = \"shl\", fnname = \"vshld_n_u64\", rettype = \"uint64_t\", argtypes = \"[uint64_t,__constrange(0,63) int]\", vals = [IntegerVal 982769883332706303,IndexVal 53], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = UINT64_C(0x0da380007fff7fff);
      clear_neon_saturated();
      //  Expect: "result" = ffe0000000000000
      result = vshld_n_u64(arg1, 53);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = UINT64_C(0xffe0000000000000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_958() {

{
   {
      int8x8_t arg1;
      int8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"rshr\", fnname = \"vrshr_n_s8\", rettype = \"int8x8_t\", argtypes = \"[int8x8_t,__constrange(1,8) int]\", vals = [VectorVal [IntegerVal 0,IntegerVal 127,IntegerVal (-64),IntegerVal (-44),IntegerVal (-128),IntegerVal (-1),IntegerVal (-1),IntegerVal (-1)],IndexVal 7], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s8(UINT64_C(0xffffff80d4c07f00));
      clear_neon_saturated();
      //  Expect: "result" = 000000ff00000100
      result = vrshr_n_s8(arg1, 7);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s8(result), 0);
      exp = UINT64_C(0x000000ff00000100);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_959() {

{
   {
      int16x4_t arg1;
      int16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"rshr\", fnname = \"vrshr_n_s16\", rettype = \"int16x4_t\", argtypes = \"[int16x4_t,__constrange(1,16) int]\", vals = [VectorVal [IntegerVal (-32768),IntegerVal (-1),IntegerVal 0,IntegerVal (-32768)],IndexVal 8], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s16(UINT64_C(0x80000000ffff8000));
      clear_neon_saturated();
      //  Expect: "result" = ff8000000000ff80
      result = vrshr_n_s16(arg1, 8);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s16(result), 0);
      exp = UINT64_C(0xff8000000000ff80);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_960() {

{
   {
      int32x2_t arg1;
      int32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"rshr\", fnname = \"vrshr_n_s32\", rettype = \"int32x2_t\", argtypes = \"[int32x2_t,__constrange(1,32) int]\", vals = [VectorVal [IntegerVal 32768,IntegerVal (-32768)],IndexVal 8], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s32(UINT64_C(0xffff800000008000));
      clear_neon_saturated();
      //  Expect: "result" = ffffff8000000080
      result = vrshr_n_s32(arg1, 8);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s32(result), 0);
      exp = UINT64_C(0xffffff8000000080);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_961() {

{
   {
      int64x1_t arg1;
      int64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"rshr\", fnname = \"vrshr_n_s64\", rettype = \"int64x1_t\", argtypes = \"[int64x1_t,__constrange(1,64) int]\", vals = [VectorVal [IntegerVal (-281474976645121)],IndexVal 26], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s64(UINT64_C(0xffff00000000ffff));
      clear_neon_saturated();
      //  Expect: "result" = ffffffffffc00000
      result = vrshr_n_s64(arg1, 26);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s64(result), 0);
      exp = UINT64_C(0xffffffffffc00000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_962() {

{
   {
      uint8x8_t arg1;
      uint8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"rshr\", fnname = \"vrshr_n_u8\", rettype = \"uint8x8_t\", argtypes = \"[uint8x8_t,__constrange(1,8) int]\", vals = [VectorVal [IntegerVal 128,IntegerVal 127,IntegerVal 0,IntegerVal 255,IntegerVal 201,IntegerVal 87,IntegerVal 217,IntegerVal 130],IndexVal 3], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u8(UINT64_C(0x82d957c9ff007f80));
      clear_neon_saturated();
      //  Expect: "result" = 101b0b1920001010
      result = vrshr_n_u8(arg1, 3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u8(result), 0);
      exp = UINT64_C(0x101b0b1920001010);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_963() {

{
   {
      uint16x4_t arg1;
      uint16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"rshr\", fnname = \"vrshr_n_u16\", rettype = \"uint16x4_t\", argtypes = \"[uint16x4_t,__constrange(1,16) int]\", vals = [VectorVal [IntegerVal 0,IntegerVal 32768,IntegerVal 46754,IntegerVal 48179],IndexVal 15], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u16(UINT64_C(0xbc33b6a280000000));
      clear_neon_saturated();
      //  Expect: "result" = 0001000100010000
      result = vrshr_n_u16(arg1, 15);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u16(result), 0);
      exp = UINT64_C(0x0001000100010000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_964() {

{
   {
      uint32x2_t arg1;
      uint32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"rshr\", fnname = \"vrshr_n_u32\", rettype = \"uint32x2_t\", argtypes = \"[uint32x2_t,__constrange(1,32) int]\", vals = [VectorVal [IntegerVal 4294901760,IntegerVal 2147549183],IndexVal 14], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u32(UINT64_C(0x8000ffffffff0000));
      clear_neon_saturated();
      //  Expect: "result" = 000200040003fffc
      result = vrshr_n_u32(arg1, 14);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u32(result), 0);
      exp = UINT64_C(0x000200040003fffc);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_965() {

{
   {
      uint64x1_t arg1;
      uint64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"rshr\", fnname = \"vrshr_n_u64\", rettype = \"uint64x1_t\", argtypes = \"[uint64x1_t,__constrange(1,64) int]\", vals = [VectorVal [IntegerVal 50876035104768],IndexVal 24], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u64(UINT64_C(0x00002e4580000000));
      clear_neon_saturated();
      //  Expect: "result" = 00000000002e4580
      result = vrshr_n_u64(arg1, 24);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(result, 0);
      exp = UINT64_C(0x00000000002e4580);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_966() {

{
   {
      int8x16_t arg1;
      int8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"rshr\", fnname = \"vrshrq_n_s8\", rettype = \"int8x16_t\", argtypes = \"[int8x16_t,__constrange(1,8) int]\", vals = [VectorVal [IntegerVal 127,IntegerVal (-128),IntegerVal 127,IntegerVal (-65),IntegerVal (-122),IntegerVal (-128),IntegerVal 0,IntegerVal (-128),IntegerVal (-128),IntegerVal 0,IntegerVal (-128),IntegerVal 127,IntegerVal (-128),IntegerVal (-128),IntegerVal (-128),IntegerVal (-1)],IndexVal 2], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s8(vcreate_s8(UINT64_C(0x80008086bf7f807f)),
                         vcreate_s8(UINT64_C(0xff8080807f800080)));
      clear_neon_saturated();
      //  Expect: "result" = 00e0e0e020e000e0e000e0e2f020e020
      result = vrshrq_n_s8(arg1, 2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result), 0);
         exp = UINT64_C(0xe000e0e2f020e020);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result), 1);
         exp = UINT64_C(0x00e0e0e020e000e0);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_967() {

{
   {
      int16x8_t arg1;
      int16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"rshr\", fnname = \"vrshrq_n_s16\", rettype = \"int16x8_t\", argtypes = \"[int16x8_t,__constrange(1,16) int]\", vals = [VectorVal [IntegerVal (-4900),IntegerVal (-32768),IntegerVal (-32768),IntegerVal 0,IntegerVal (-1),IntegerVal 32767,IntegerVal (-1),IntegerVal 32767],IndexVal 12], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s16(vcreate_s16(UINT64_C(0x000080008000ecdc)),
                          vcreate_s16(UINT64_C(0x7fffffff7fffffff)));
      clear_neon_saturated();
      //  Expect: "result" = 00080000000800000000fff8fff8ffff
      result = vrshrq_n_s16(arg1, 12);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 0);
         exp = UINT64_C(0x0000fff8fff8ffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 1);
         exp = UINT64_C(0x0008000000080000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_968() {

{
   {
      int32x4_t arg1;
      int32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"rshr\", fnname = \"vrshrq_n_s32\", rettype = \"int32x4_t\", argtypes = \"[int32x4_t,__constrange(1,32) int]\", vals = [VectorVal [IntegerVal (-1064730625),IntegerVal 1978892287,IntegerVal 0,IntegerVal 1177124863],IndexVal 24], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s32(vcreate_s32(UINT64_C(0x75f37fffc0897fff)),
                          vcreate_s32(UINT64_C(0x46297fff00000000)));
      clear_neon_saturated();
      //  Expect: "result" = 000000460000000000000076ffffffc1
      result = vrshrq_n_s32(arg1, 24);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 0);
         exp = UINT64_C(0x00000076ffffffc1);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 1);
         exp = UINT64_C(0x0000004600000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_969() {

{
   {
      int64x2_t arg1;
      int64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"rshr\", fnname = \"vrshrq_n_s64\", rettype = \"int64x2_t\", argtypes = \"[int64x2_t,__constrange(1,64) int]\", vals = [VectorVal [IntegerVal (-7606393306771155056),IntegerVal (-730751338)],IndexVal 1], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s64(vcreate_s64(UINT64_C(0x9670a9967fff1790)),
                          vcreate_s64(UINT64_C(0xffffffffd4719e96)));
      clear_neon_saturated();
      //  Expect: "result" = ffffffffea38cf4bcb3854cb3fff8bc8
      result = vrshrq_n_s64(arg1, 1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 0);
         exp = UINT64_C(0xcb3854cb3fff8bc8);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 1);
         exp = UINT64_C(0xffffffffea38cf4b);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_970() {

{
   {
      uint8x16_t arg1;
      uint8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"rshr\", fnname = \"vrshrq_n_u8\", rettype = \"uint8x16_t\", argtypes = \"[uint8x16_t,__constrange(1,8) int]\", vals = [VectorVal [IntegerVal 0,IntegerVal 128,IntegerVal 255,IntegerVal 0,IntegerVal 127,IntegerVal 255,IntegerVal 127,IntegerVal 128,IntegerVal 0,IntegerVal 103,IntegerVal 127,IntegerVal 128,IntegerVal 1,IntegerVal 8,IntegerVal 255,IntegerVal 127],IndexVal 5], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u8(vcreate_u8(UINT64_C(0x807fff7f00ff8000)),
                         vcreate_u8(UINT64_C(0x7fff0801807f6700)));
      clear_neon_saturated();
      //  Expect: "result" = 04080000040403000404080400080400
      result = vrshrq_n_u8(arg1, 5);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 0);
         exp = UINT64_C(0x0404080400080400);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 1);
         exp = UINT64_C(0x0408000004040300);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_971() {

{
   {
      uint16x8_t arg1;
      uint16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"rshr\", fnname = \"vrshrq_n_u16\", rettype = \"uint16x8_t\", argtypes = \"[uint16x8_t,__constrange(1,16) int]\", vals = [VectorVal [IntegerVal 65535,IntegerVal 0,IntegerVal 0,IntegerVal 65535,IntegerVal 32768,IntegerVal 32768,IntegerVal 0,IntegerVal 33584],IndexVal 1], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u16(vcreate_u16(UINT64_C(0xffff00000000ffff)),
                          vcreate_u16(UINT64_C(0x8330000080008000)));
      clear_neon_saturated();
      //  Expect: "result" = 41980000400040008000000000008000
      result = vrshrq_n_u16(arg1, 1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 0);
         exp = UINT64_C(0x8000000000008000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 1);
         exp = UINT64_C(0x4198000040004000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_972() {

{
   {
      uint32x4_t arg1;
      uint32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"rshr\", fnname = \"vrshrq_n_u32\", rettype = \"uint32x4_t\", argtypes = \"[uint32x4_t,__constrange(1,32) int]\", vals = [VectorVal [IntegerVal 2147549183,IntegerVal 2147516415,IntegerVal 2147450880,IntegerVal 3930226687],IndexVal 6], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u32(vcreate_u32(UINT64_C(0x80007fff8000ffff)),
                          vcreate_u32(UINT64_C(0xea427fff7fff8000)));
      clear_neon_saturated();
      //  Expect: "result" = 03a90a0001fffe000200020002000400
      result = vrshrq_n_u32(arg1, 6);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 0);
         exp = UINT64_C(0x0200020002000400);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 1);
         exp = UINT64_C(0x03a90a0001fffe00);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_973() {

{
   {
      uint64x2_t arg1;
      uint64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"rshr\", fnname = \"vrshrq_n_u64\", rettype = \"uint64x2_t\", argtypes = \"[uint64x2_t,__constrange(1,64) int]\", vals = [VectorVal [IntegerVal 18446744071796228096,IntegerVal 9223653509684060776],IndexVal 51], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u64(vcreate_u64(UINT64_C(0xffffffff8df50000)),
                          vcreate_u64(UINT64_C(0x8000ffff8000e268)));
      clear_neon_saturated();
      //  Expect: "result" = 00000000000010000000000000002000
      result = vrshrq_n_u64(arg1, 51);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 0);
         exp = UINT64_C(0x0000000000002000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 1);
         exp = UINT64_C(0x0000000000001000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_974() {

{
   {
      int64_t arg1;
      int64_t result;
      char* str1 = "ReproInfo2 {semantics = \"rshr\", fnname = \"vrshrd_n_s64\", rettype = \"int64_t\", argtypes = \"[int64_t,__constrange(1,64) int]\", vals = [IntegerVal 9223090564025614335,IndexVal 47], start_saturated = False}";
      int reported = 0;
      int64_t got;
      int64_t exp;
      arg1 = INT64_C(9223090564025614335);
      clear_neon_saturated();
      //  Expect: "result" = 000000000000fffe
      result = vrshrd_n_s64(arg1, 47);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = INT64_C(65534);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIi64 " Got: %" PRIi64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_975() {

{
   {
      uint64_t arg1;
      uint64_t result;
      char* str1 = "ReproInfo2 {semantics = \"rshr\", fnname = \"vrshrd_n_u64\", rettype = \"uint64_t\", argtypes = \"[uint64_t,__constrange(1,64) int]\", vals = [IntegerVal 18446603334747302858,IndexVal 4], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = UINT64_C(0xffff7fffa8262bca);
      clear_neon_saturated();
      //  Expect: "result" = 0ffff7fffa8262bd
      result = vrshrd_n_u64(arg1, 4);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = UINT64_C(0x0ffff7fffa8262bd);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_976() {

{
   {
      int8x8_t arg1;
      int8x8_t arg2;
      int8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"sra\", fnname = \"vsra_n_s8\", rettype = \"int8x8_t\", argtypes = \"[int8x8_t,int8x8_t,__constrange(1,8) int]\", vals = [VectorVal [IntegerVal (-1),IntegerVal (-86),IntegerVal 55,IntegerVal 0,IntegerVal (-1),IntegerVal 0,IntegerVal 127,IntegerVal 0],VectorVal [IntegerVal (-50),IntegerVal 0,IntegerVal 0,IntegerVal (-128),IntegerVal 0,IntegerVal 127,IntegerVal (-13),IntegerVal 0],IndexVal 8], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s8(UINT64_C(0x007f00ff0037aaff));
      arg2 = vcreate_s8(UINT64_C(0x00f37f00800000ce));
      clear_neon_saturated();
      //  Expect: "result" = 007e00ffff37aafe
      result = vsra_n_s8(arg1, arg2, 8);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s8(result), 0);
      exp = UINT64_C(0x007e00ffff37aafe);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_977() {

{
   {
      int16x4_t arg1;
      int16x4_t arg2;
      int16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"sra\", fnname = \"vsra_n_s16\", rettype = \"int16x4_t\", argtypes = \"[int16x4_t,int16x4_t,__constrange(1,16) int]\", vals = [VectorVal [IntegerVal 0,IntegerVal (-12096),IntegerVal 32767,IntegerVal 27528],VectorVal [IntegerVal 32767,IntegerVal (-32768),IntegerVal 32767,IntegerVal (-32768)],IndexVal 13], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s16(UINT64_C(0x6b887fffd0c00000));
      arg2 = vcreate_s16(UINT64_C(0x80007fff80007fff));
      clear_neon_saturated();
      //  Expect: "result" = 6b848002d0bc0003
      result = vsra_n_s16(arg1, arg2, 13);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s16(result), 0);
      exp = UINT64_C(0x6b848002d0bc0003);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_978() {

{
   {
      int32x2_t arg1;
      int32x2_t arg2;
      int32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"sra\", fnname = \"vsra_n_s32\", rettype = \"int32x2_t\", argtypes = \"[int32x2_t,int32x2_t,__constrange(1,32) int]\", vals = [VectorVal [IntegerVal 124059648,IntegerVal (-2147474125)],VectorVal [IntegerVal (-2147430634),IntegerVal 802422783],IndexVal 2], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s32(UINT64_C(0x8000253307650000));
      arg2 = vcreate_s32(UINT64_C(0x2fd3ffff8000cf16));
      clear_neon_saturated();
      //  Expect: "result" = 8bf52532e76533c5
      result = vsra_n_s32(arg1, arg2, 2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s32(result), 0);
      exp = UINT64_C(0x8bf52532e76533c5);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_979() {

{
   {
      int64x1_t arg1;
      int64x1_t arg2;
      int64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"sra\", fnname = \"vsra_n_s64\", rettype = \"int64x1_t\", argtypes = \"[int64x1_t,int64x1_t,__constrange(1,64) int]\", vals = [VectorVal [IntegerVal 4294901760],VectorVal [IntegerVal (-140735340838913)],IndexVal 4], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s64(UINT64_C(0x00000000ffff0000));
      arg2 = vcreate_s64(UINT64_C(0xffff800080007fff));
      clear_neon_saturated();
      //  Expect: "result" = fffff80107ff07ff
      result = vsra_n_s64(arg1, arg2, 4);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s64(result), 0);
      exp = UINT64_C(0xfffff80107ff07ff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_980() {

{
   {
      uint8x8_t arg1;
      uint8x8_t arg2;
      uint8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"sra\", fnname = \"vsra_n_u8\", rettype = \"uint8x8_t\", argtypes = \"[uint8x8_t,uint8x8_t,__constrange(1,8) int]\", vals = [VectorVal [IntegerVal 0,IntegerVal 127,IntegerVal 127,IntegerVal 12,IntegerVal 128,IntegerVal 244,IntegerVal 63,IntegerVal 220],VectorVal [IntegerVal 0,IntegerVal 127,IntegerVal 0,IntegerVal 255,IntegerVal 255,IntegerVal 255,IntegerVal 79,IntegerVal 255],IndexVal 5], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u8(UINT64_C(0xdc3ff4800c7f7f00));
      arg2 = vcreate_u8(UINT64_C(0xff4fffffff007f00));
      clear_neon_saturated();
      //  Expect: "result" = e341fb87137f8200
      result = vsra_n_u8(arg1, arg2, 5);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u8(result), 0);
      exp = UINT64_C(0xe341fb87137f8200);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_981() {

{
   {
      uint16x4_t arg1;
      uint16x4_t arg2;
      uint16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"sra\", fnname = \"vsra_n_u16\", rettype = \"uint16x4_t\", argtypes = \"[uint16x4_t,uint16x4_t,__constrange(1,16) int]\", vals = [VectorVal [IntegerVal 32768,IntegerVal 32767,IntegerVal 65535,IntegerVal 32767],VectorVal [IntegerVal 30129,IntegerVal 32768,IntegerVal 32767,IntegerVal 65535],IndexVal 10], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u16(UINT64_C(0x7fffffff7fff8000));
      arg2 = vcreate_u16(UINT64_C(0xffff7fff800075b1));
      clear_neon_saturated();
      //  Expect: "result" = 803e001e801f801d
      result = vsra_n_u16(arg1, arg2, 10);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u16(result), 0);
      exp = UINT64_C(0x803e001e801f801d);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_982() {

{
   {
      uint32x2_t arg1;
      uint32x2_t arg2;
      uint32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"sra\", fnname = \"vsra_n_u32\", rettype = \"uint32x2_t\", argtypes = \"[uint32x2_t,uint32x2_t,__constrange(1,32) int]\", vals = [VectorVal [IntegerVal 2147516416,IntegerVal 2095680804],VectorVal [IntegerVal 559120384,IntegerVal 4294935235],IndexVal 8], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u32(UINT64_C(0x7ce98d2480008000));
      arg2 = vcreate_u32(UINT64_C(0xffff82c321538000));
      clear_neon_saturated();
      //  Expect: "result" = 7de98ca68021d380
      result = vsra_n_u32(arg1, arg2, 8);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u32(result), 0);
      exp = UINT64_C(0x7de98ca68021d380);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_983() {

{
   {
      uint64x1_t arg1;
      uint64x1_t arg2;
      uint64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"sra\", fnname = \"vsra_n_u64\", rettype = \"uint64x1_t\", argtypes = \"[uint64x1_t,uint64x1_t,__constrange(1,64) int]\", vals = [VectorVal [IntegerVal 15840707999686426624],VectorVal [IntegerVal 252977868701696],IndexVal 50], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u64(UINT64_C(0xdbd57fff7fff8000));
      arg2 = vcreate_u64(UINT64_C(0x0000e61500000000));
      clear_neon_saturated();
      //  Expect: "result" = dbd57fff7fff8000
      result = vsra_n_u64(arg1, arg2, 50);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(result, 0);
      exp = UINT64_C(0xdbd57fff7fff8000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_984() {

{
   {
      int8x16_t arg1;
      int8x16_t arg2;
      int8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"sra\", fnname = \"vsraq_n_s8\", rettype = \"int8x16_t\", argtypes = \"[int8x16_t,int8x16_t,__constrange(1,8) int]\", vals = [VectorVal [IntegerVal 0,IntegerVal 127,IntegerVal (-74),IntegerVal 60,IntegerVal (-1),IntegerVal 12,IntegerVal (-128),IntegerVal 0,IntegerVal (-1),IntegerVal 127,IntegerVal (-1),IntegerVal 117,IntegerVal (-1),IntegerVal 0,IntegerVal (-128),IntegerVal (-1)],VectorVal [IntegerVal (-1),IntegerVal (-1),IntegerVal (-1),IntegerVal (-1),IntegerVal 70,IntegerVal 127,IntegerVal 127,IntegerVal (-1),IntegerVal 6,IntegerVal 72,IntegerVal (-91),IntegerVal (-1),IntegerVal 127,IntegerVal 127,IntegerVal 127,IntegerVal 127],IndexVal 2], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s8(vcreate_s8(UINT64_C(0x00800cff3cb67f00)),
                         vcreate_s8(UINT64_C(0xff8000ff75ff7fff)));
      arg2 = vcombine_s8(vcreate_s8(UINT64_C(0xff7f7f46ffffffff)),
                         vcreate_s8(UINT64_C(0x7f7f7f7fffa54806)));
      clear_neon_saturated();
      //  Expect: "result" = 1e9f1f1e74e89100ff9f2b103bb57eff
      result = vsraq_n_s8(arg1, arg2, 2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result), 0);
         exp = UINT64_C(0xff9f2b103bb57eff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result), 1);
         exp = UINT64_C(0x1e9f1f1e74e89100);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_985() {

{
   {
      int16x8_t arg1;
      int16x8_t arg2;
      int16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"sra\", fnname = \"vsraq_n_s16\", rettype = \"int16x8_t\", argtypes = \"[int16x8_t,int16x8_t,__constrange(1,16) int]\", vals = [VectorVal [IntegerVal (-14665),IntegerVal 32767,IntegerVal 0,IntegerVal 0,IntegerVal 0,IntegerVal 26449,IntegerVal 32767,IntegerVal (-32768)],VectorVal [IntegerVal 32767,IntegerVal (-32768),IntegerVal 32767,IntegerVal 32767,IntegerVal 0,IntegerVal 32767,IntegerVal 3538,IntegerVal (-1)],IndexVal 8], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s16(vcreate_s16(UINT64_C(0x000000007fffc6b7)),
                          vcreate_s16(UINT64_C(0x80007fff67510000)));
      arg2 = vcombine_s16(vcreate_s16(UINT64_C(0x7fff7fff80007fff)),
                          vcreate_s16(UINT64_C(0xffff0dd27fff0000)));
      clear_neon_saturated();
      //  Expect: "result" = 7fff800c67d00000007f007f7f7fc736
      result = vsraq_n_s16(arg1, arg2, 8);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 0);
         exp = UINT64_C(0x007f007f7f7fc736);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 1);
         exp = UINT64_C(0x7fff800c67d00000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_986() {

{
   {
      int32x4_t arg1;
      int32x4_t arg2;
      int32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"sra\", fnname = \"vsraq_n_s32\", rettype = \"int32x4_t\", argtypes = \"[int32x4_t,int32x4_t,__constrange(1,32) int]\", vals = [VectorVal [IntegerVal 2133655551,IntegerVal (-2147450920),IntegerVal (-2147483648),IntegerVal (-2147418113)],VectorVal [IntegerVal (-2147483648),IntegerVal 2147450879,IntegerVal 32767,IntegerVal 53483104],IndexVal 14], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s32(vcreate_s32(UINT64_C(0x80007fd87f2cffff)),
                          vcreate_s32(UINT64_C(0x8000ffff80000000)));
      arg2 = vcombine_s32(vcreate_s32(UINT64_C(0x7fff7fff80000000)),
                          vcreate_s32(UINT64_C(0x0330166000007fff)));
      clear_neon_saturated();
      //  Expect: "result" = 80010cbf8000000180027fd57f2affff
      result = vsraq_n_s32(arg1, arg2, 14);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 0);
         exp = UINT64_C(0x80027fd57f2affff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 1);
         exp = UINT64_C(0x80010cbf80000001);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_987() {

{
   {
      int64x2_t arg1;
      int64x2_t arg2;
      int64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"sra\", fnname = \"vsraq_n_s64\", rettype = \"int64x2_t\", argtypes = \"[int64x2_t,int64x2_t,__constrange(1,64) int]\", vals = [VectorVal [IntegerVal 140741783257088,IntegerVal (-5363505683369066496)],VectorVal [IntegerVal 140739635871744,IntegerVal 9223231295071476688],IndexVal 23], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s64(vcreate_s64(UINT64_C(0x00008000ffff0000)),
                          vcreate_s64(UINT64_C(0xb590ffff7fff8000)));
      arg2 = vcombine_s64(vcreate_s64(UINT64_C(0x0000800080008000)),
                          vcreate_s64(UINT64_C(0x7fff7fff00005bd0)));
      clear_neon_saturated();
      //  Expect: "result" = b59100ff7eff7e000000800100ff0100
      result = vsraq_n_s64(arg1, arg2, 23);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 0);
         exp = UINT64_C(0x0000800100ff0100);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 1);
         exp = UINT64_C(0xb59100ff7eff7e00);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_988() {

{
   {
      uint8x16_t arg1;
      uint8x16_t arg2;
      uint8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"sra\", fnname = \"vsraq_n_u8\", rettype = \"uint8x16_t\", argtypes = \"[uint8x16_t,uint8x16_t,__constrange(1,8) int]\", vals = [VectorVal [IntegerVal 255,IntegerVal 166,IntegerVal 128,IntegerVal 127,IntegerVal 128,IntegerVal 0,IntegerVal 127,IntegerVal 148,IntegerVal 128,IntegerVal 127,IntegerVal 0,IntegerVal 255,IntegerVal 171,IntegerVal 128,IntegerVal 128,IntegerVal 255],VectorVal [IntegerVal 255,IntegerVal 128,IntegerVal 128,IntegerVal 255,IntegerVal 216,IntegerVal 128,IntegerVal 128,IntegerVal 127,IntegerVal 0,IntegerVal 128,IntegerVal 255,IntegerVal 128,IntegerVal 128,IntegerVal 0,IntegerVal 0,IntegerVal 127],IndexVal 2], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u8(vcreate_u8(UINT64_C(0x947f00807f80a6ff)),
                         vcreate_u8(UINT64_C(0xff8080abff007f80)));
      arg2 = vcombine_u8(vcreate_u8(UINT64_C(0x7f8080d8ff8080ff)),
                         vcreate_u8(UINT64_C(0x7f00008080ff8000)));
      clear_neon_saturated();
      //  Expect: "result" = 1e8080cb1f3f9f80b39f20b6bea0c63e
      result = vsraq_n_u8(arg1, arg2, 2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 0);
         exp = UINT64_C(0xb39f20b6bea0c63e);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 1);
         exp = UINT64_C(0x1e8080cb1f3f9f80);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_989() {

{
   {
      uint16x8_t arg1;
      uint16x8_t arg2;
      uint16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"sra\", fnname = \"vsraq_n_u16\", rettype = \"uint16x8_t\", argtypes = \"[uint16x8_t,uint16x8_t,__constrange(1,16) int]\", vals = [VectorVal [IntegerVal 32768,IntegerVal 65535,IntegerVal 0,IntegerVal 65535,IntegerVal 65535,IntegerVal 0,IntegerVal 32768,IntegerVal 32768],VectorVal [IntegerVal 32767,IntegerVal 65535,IntegerVal 0,IntegerVal 0,IntegerVal 35316,IntegerVal 65535,IntegerVal 3346,IntegerVal 0],IndexVal 9], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u16(vcreate_u16(UINT64_C(0xffff0000ffff8000)),
                          vcreate_u16(UINT64_C(0x800080000000ffff)));
      arg2 = vcombine_u16(vcreate_u16(UINT64_C(0x00000000ffff7fff)),
                          vcreate_u16(UINT64_C(0x00000d12ffff89f4)));
      clear_neon_saturated();
      //  Expect: "result" = 80008006007f0043ffff0000007e803f
      result = vsraq_n_u16(arg1, arg2, 9);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 0);
         exp = UINT64_C(0xffff0000007e803f);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 1);
         exp = UINT64_C(0x80008006007f0043);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_990() {

{
   {
      uint32x4_t arg1;
      uint32x4_t arg2;
      uint32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"sra\", fnname = \"vsraq_n_u32\", rettype = \"uint32x4_t\", argtypes = \"[uint32x4_t,uint32x4_t,__constrange(1,32) int]\", vals = [VectorVal [IntegerVal 2147549183,IntegerVal 32767,IntegerVal 2147539894,IntegerVal 2147516415],VectorVal [IntegerVal 1891041279,IntegerVal 2147483647,IntegerVal 32768,IntegerVal 92766207],IndexVal 29], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u32(vcreate_u32(UINT64_C(0x00007fff8000ffff)),
                          vcreate_u32(UINT64_C(0x80007fff8000dbb6)));
      arg2 = vcombine_u32(vcreate_u32(UINT64_C(0x7fffffff70b6ffff)),
                          vcreate_u32(UINT64_C(0x05877fff00008000)));
      clear_neon_saturated();
      //  Expect: "result" = 80007fff8000dbb60000800280010002
      result = vsraq_n_u32(arg1, arg2, 29);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 0);
         exp = UINT64_C(0x0000800280010002);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 1);
         exp = UINT64_C(0x80007fff8000dbb6);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_991() {

{
   {
      uint64x2_t arg1;
      uint64x2_t arg2;
      uint64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"sra\", fnname = \"vsraq_n_u64\", rettype = \"uint64x2_t\", argtypes = \"[uint64x2_t,uint64x2_t,__constrange(1,64) int]\", vals = [VectorVal [IntegerVal 18446462600880324607,IntegerVal 18446462603027775488],VectorVal [IntegerVal 17509359075433938943,IntegerVal 9223653509684035584],IndexVal 22], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u64(vcreate_u64(UINT64_C(0xffff00007fffffff)),
                          vcreate_u64(UINT64_C(0xffff0000ffff8000)));
      arg2 = vcombine_u64(vcreate_u64(UINT64_C(0xf2fdbd4f80007fff)),
                          vcreate_u64(UINT64_C(0x8000ffff80008000)));
      clear_neon_saturated();
      //  Expect: "result" = ffff020103ff7e00ffff03cc76f53dff
      result = vsraq_n_u64(arg1, arg2, 22);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 0);
         exp = UINT64_C(0xffff03cc76f53dff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 1);
         exp = UINT64_C(0xffff020103ff7e00);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_992() {

{
   {
      int64_t arg1;
      int64_t arg2;
      int64_t result;
      char* str1 = "ReproInfo2 {semantics = \"sra\", fnname = \"vsrad_n_s64\", rettype = \"int64_t\", argtypes = \"[int64_t,int64_t,__constrange(1,64) int]\", vals = [IntegerVal 9223108899241000959,IntegerVal (-140733193420800),IndexVal 38], start_saturated = False}";
      int reported = 0;
      int64_t got;
      int64_t exp;
      arg1 = INT64_C(9223108899241000959);
      arg2 = INT64_C(-140733193420800);
      clear_neon_saturated();
      //  Expect: "result" = 7fff10ad8000fdff
      result = vsrad_n_s64(arg1, arg2, 38);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = INT64_C(9223108899241000447);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIi64 " Got: %" PRIi64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_993() {

{
   {
      uint64_t arg1;
      uint64_t arg2;
      uint64_t result;
      char* str1 = "ReproInfo2 {semantics = \"sra\", fnname = \"vsrad_n_u64\", rettype = \"uint64_t\", argtypes = \"[uint64_t,uint64_t,__constrange(1,64) int]\", vals = [IntegerVal 9223512772195647487,IntegerVal 9223190808562302975,IndexVal 12], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = UINT64_C(0x80007fff7fffffff);
      arg2 = UINT64_C(0x7fff5b2c8000ffff);
      clear_neon_saturated();
      //  Expect: "result" = 80087ff532c8000e
      result = vsrad_n_u64(arg1, arg2, 12);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = UINT64_C(0x80087ff532c8000e);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_994() {

{
   {
      int8x8_t arg1;
      int8x8_t arg2;
      int8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"rsra\", fnname = \"vrsra_n_s8\", rettype = \"int8x8_t\", argtypes = \"[int8x8_t,int8x8_t,__constrange(1,8) int]\", vals = [VectorVal [IntegerVal (-28),IntegerVal 127,IntegerVal 0,IntegerVal (-1),IntegerVal 127,IntegerVal (-60),IntegerVal (-1),IntegerVal 127],VectorVal [IntegerVal 0,IntegerVal (-1),IntegerVal 127,IntegerVal 127,IntegerVal (-1),IntegerVal 127,IntegerVal (-128),IntegerVal 0],IndexVal 8], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s8(UINT64_C(0x7fffc47fff007fe4));
      arg2 = vcreate_s8(UINT64_C(0x00807fff7f7fff00));
      clear_neon_saturated();
      //  Expect: "result" = 7fffc47fff007fe4
      result = vrsra_n_s8(arg1, arg2, 8);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s8(result), 0);
      exp = UINT64_C(0x7fffc47fff007fe4);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_995() {

{
   {
      int16x4_t arg1;
      int16x4_t arg2;
      int16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"rsra\", fnname = \"vrsra_n_s16\", rettype = \"int16x4_t\", argtypes = \"[int16x4_t,int16x4_t,__constrange(1,16) int]\", vals = [VectorVal [IntegerVal (-21551),IntegerVal (-32768),IntegerVal (-1),IntegerVal 32767],VectorVal [IntegerVal (-299),IntegerVal (-1),IntegerVal 32767,IntegerVal 32767],IndexVal 15], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s16(UINT64_C(0x7fffffff8000abd1));
      arg2 = vcreate_s16(UINT64_C(0x7fff7ffffffffed5));
      clear_neon_saturated();
      //  Expect: "result" = 800000008000abd1
      result = vrsra_n_s16(arg1, arg2, 15);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s16(result), 0);
      exp = UINT64_C(0x800000008000abd1);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_996() {

{
   {
      int32x2_t arg1;
      int32x2_t arg2;
      int32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"rsra\", fnname = \"vrsra_n_s32\", rettype = \"int32x2_t\", argtypes = \"[int32x2_t,int32x2_t,__constrange(1,32) int]\", vals = [VectorVal [IntegerVal (-2147423104),IntegerVal (-2147450881)],VectorVal [IntegerVal (-2147479411),IntegerVal (-1874329601)],IndexVal 9], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s32(UINT64_C(0x80007fff8000ec80));
      arg2 = vcreate_s32(UINT64_C(0x9047ffff8000108d));
      clear_neon_saturated();
      //  Expect: "result" = 7fc8a3ff7fc0ec88
      result = vrsra_n_s32(arg1, arg2, 9);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s32(result), 0);
      exp = UINT64_C(0x7fc8a3ff7fc0ec88);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_997() {

{
   {
      int64x1_t arg1;
      int64x1_t arg2;
      int64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"rsra\", fnname = \"vrsra_n_s64\", rettype = \"int64x1_t\", argtypes = \"[int64x1_t,int64x1_t,__constrange(1,64) int]\", vals = [VectorVal [IntegerVal 9223231297218904063],VectorVal [IntegerVal (-9223372036854775808)],IndexVal 36], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s64(UINT64_C(0x7fff7fff7fff7fff));
      arg2 = vcreate_s64(UINT64_C(0x8000000000000000));
      clear_neon_saturated();
      //  Expect: "result" = 7fff7fff77ff7fff
      result = vrsra_n_s64(arg1, arg2, 36);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s64(result), 0);
      exp = UINT64_C(0x7fff7fff77ff7fff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_998() {

{
   {
      uint8x8_t arg1;
      uint8x8_t arg2;
      uint8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"rsra\", fnname = \"vrsra_n_u8\", rettype = \"uint8x8_t\", argtypes = \"[uint8x8_t,uint8x8_t,__constrange(1,8) int]\", vals = [VectorVal [IntegerVal 255,IntegerVal 188,IntegerVal 128,IntegerVal 97,IntegerVal 255,IntegerVal 54,IntegerVal 128,IntegerVal 127],VectorVal [IntegerVal 0,IntegerVal 255,IntegerVal 127,IntegerVal 255,IntegerVal 127,IntegerVal 127,IntegerVal 0,IntegerVal 255],IndexVal 1], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u8(UINT64_C(0x7f8036ff6180bcff));
      arg2 = vcreate_u8(UINT64_C(0xff007f7fff7fff00));
      clear_neon_saturated();
      //  Expect: "result" = ff80763fe1c03cff
      result = vrsra_n_u8(arg1, arg2, 1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u8(result), 0);
      exp = UINT64_C(0xff80763fe1c03cff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_999() {

{
   {
      uint16x4_t arg1;
      uint16x4_t arg2;
      uint16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"rsra\", fnname = \"vrsra_n_u16\", rettype = \"uint16x4_t\", argtypes = \"[uint16x4_t,uint16x4_t,__constrange(1,16) int]\", vals = [VectorVal [IntegerVal 32768,IntegerVal 2545,IntegerVal 32767,IntegerVal 49383],VectorVal [IntegerVal 32767,IntegerVal 45316,IntegerVal 0,IntegerVal 0],IndexVal 13], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u16(UINT64_C(0xc0e77fff09f18000));
      arg2 = vcreate_u16(UINT64_C(0x00000000b1047fff));
      clear_neon_saturated();
      //  Expect: "result" = c0e77fff09f78004
      result = vrsra_n_u16(arg1, arg2, 13);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u16(result), 0);
      exp = UINT64_C(0xc0e77fff09f78004);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1000() {

{
   {
      uint32x2_t arg1;
      uint32x2_t arg2;
      uint32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"rsra\", fnname = \"vrsra_n_u32\", rettype = \"uint32x2_t\", argtypes = \"[uint32x2_t,uint32x2_t,__constrange(1,32) int]\", vals = [VectorVal [IntegerVal 2147482028,IntegerVal 3626301627],VectorVal [IntegerVal 2147418112,IntegerVal 2147450880],IndexVal 3], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u32(UINT64_C(0xd824f8bb7ffff9ac));
      arg2 = vcreate_u32(UINT64_C(0x7fff80007fff0000));
      clear_neon_saturated();
      //  Expect: "result" = e824e8bb8fffd9ac
      result = vrsra_n_u32(arg1, arg2, 3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u32(result), 0);
      exp = UINT64_C(0xe824e8bb8fffd9ac);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1001() {

{
   {
      uint64x1_t arg1;
      uint64x1_t arg2;
      uint64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"rsra\", fnname = \"vrsra_n_u64\", rettype = \"uint64x1_t\", argtypes = \"[uint64x1_t,uint64x1_t,__constrange(1,64) int]\", vals = [VectorVal [IntegerVal 18446603340516130816],VectorVal [IntegerVal 9223512778638098431],IndexVal 45], start_saturated = True}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u64(UINT64_C(0xffff8000ffff8000));
      arg2 = vcreate_u64(UINT64_C(0x80008000ffffffff));
      set_neon_saturated();
      //  Expect: "result" = ffff800100038004
      result = vrsra_n_u64(arg1, arg2, 45);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      got = vget_lane_u64(result, 0);
      exp = UINT64_C(0xffff800100038004);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1002() {

{
   {
      int8x16_t arg1;
      int8x16_t arg2;
      int8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"rsra\", fnname = \"vrsraq_n_s8\", rettype = \"int8x16_t\", argtypes = \"[int8x16_t,int8x16_t,__constrange(1,8) int]\", vals = [VectorVal [IntegerVal 0,IntegerVal (-15),IntegerVal 118,IntegerVal 127,IntegerVal 0,IntegerVal 0,IntegerVal 40,IntegerVal 0,IntegerVal 66,IntegerVal 127,IntegerVal 127,IntegerVal (-38),IntegerVal (-1),IntegerVal 127,IntegerVal 50,IntegerVal (-128)],VectorVal [IntegerVal 0,IntegerVal (-128),IntegerVal (-1),IntegerVal (-114),IntegerVal (-1),IntegerVal 127,IntegerVal (-128),IntegerVal 127,IntegerVal 71,IntegerVal (-53),IntegerVal 127,IntegerVal 0,IntegerVal (-1),IntegerVal (-128),IntegerVal (-95),IntegerVal 127],IndexVal 8], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s8(vcreate_s8(UINT64_C(0x002800007f76f100)),
                         vcreate_s8(UINT64_C(0x80327fffda7f7f42)));
      arg2 = vcombine_s8(vcreate_s8(UINT64_C(0x7f807fff8eff8000)),
                         vcreate_s8(UINT64_C(0x7fa180ff007fcb47)));
      clear_neon_saturated();
      //  Expect: "result" = 80327fffda7f7f42002800007f76f100
      result = vrsraq_n_s8(arg1, arg2, 8);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result), 0);
         exp = UINT64_C(0x002800007f76f100);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result), 1);
         exp = UINT64_C(0x80327fffda7f7f42);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1003() {

{
   {
      int16x8_t arg1;
      int16x8_t arg2;
      int16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"rsra\", fnname = \"vrsraq_n_s16\", rettype = \"int16x8_t\", argtypes = \"[int16x8_t,int16x8_t,__constrange(1,16) int]\", vals = [VectorVal [IntegerVal 3548,IntegerVal 0,IntegerVal 0,IntegerVal 32767,IntegerVal (-32768),IntegerVal 32767,IntegerVal 0,IntegerVal (-1)],VectorVal [IntegerVal (-19504),IntegerVal (-32768),IntegerVal (-14949),IntegerVal (-17959),IntegerVal 11793,IntegerVal 32767,IntegerVal (-32768),IntegerVal (-32768)],IndexVal 8], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s16(vcreate_s16(UINT64_C(0x7fff000000000ddc)),
                          vcreate_s16(UINT64_C(0xffff00007fff8000)));
      arg2 = vcombine_s16(vcreate_s16(UINT64_C(0xb9d9c59b8000b3d0)),
                          vcreate_s16(UINT64_C(0x800080007fff2e11)));
      clear_neon_saturated();
      //  Expect: "result" = ff7fff80807f802e7fb9ffc6ff800d90
      result = vrsraq_n_s16(arg1, arg2, 8);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 0);
         exp = UINT64_C(0x7fb9ffc6ff800d90);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 1);
         exp = UINT64_C(0xff7fff80807f802e);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1004() {

{
   {
      int32x4_t arg1;
      int32x4_t arg2;
      int32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"rsra\", fnname = \"vrsraq_n_s32\", rettype = \"int32x4_t\", argtypes = \"[int32x4_t,int32x4_t,__constrange(1,32) int]\", vals = [VectorVal [IntegerVal (-2147483648),IntegerVal 32767,IntegerVal 646356627,IntegerVal (-2147450881)],VectorVal [IntegerVal (-2147483648),IntegerVal (-2147418113),IntegerVal (-2147483648),IntegerVal 32767],IndexVal 31], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s32(vcreate_s32(UINT64_C(0x00007fff80000000)),
                          vcreate_s32(UINT64_C(0x80007fff26869e93)));
      arg2 = vcombine_s32(vcreate_s32(UINT64_C(0x8000ffff80000000)),
                          vcreate_s32(UINT64_C(0x00007fff80000000)));
      clear_neon_saturated();
      //  Expect: "result" = 80007fff26869e9200007ffe7fffffff
      result = vrsraq_n_s32(arg1, arg2, 31);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 0);
         exp = UINT64_C(0x00007ffe7fffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 1);
         exp = UINT64_C(0x80007fff26869e92);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1005() {

{
   {
      int64x2_t arg1;
      int64x2_t arg2;
      int64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"rsra\", fnname = \"vrsraq_n_s64\", rettype = \"int64x2_t\", argtypes = \"[int64x2_t,int64x2_t,__constrange(1,64) int]\", vals = [VectorVal [IntegerVal 9223090561878111665,IntegerVal (-140739635838976)],VectorVal [IntegerVal (-63277753204737),IntegerVal (-9223372032559841280)],IndexVal 21], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s64(vcreate_s64(UINT64_C(0x7fff00000000b5b1)),
                          vcreate_s64(UINT64_C(0xffff7fff80000000)));
      arg2 = vcombine_s64(vcreate_s64(UINT64_C(0xffffc672ffff7fff)),
                          vcreate_s64(UINT64_C(0x80000000ffff8000)));
      clear_neon_saturated();
      //  Expect: "result" = ffff7bff800008007ffefffffe344db1
      result = vrsraq_n_s64(arg1, arg2, 21);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 0);
         exp = UINT64_C(0x7ffefffffe344db1);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 1);
         exp = UINT64_C(0xffff7bff80000800);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1006() {

{
   {
      uint8x16_t arg1;
      uint8x16_t arg2;
      uint8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"rsra\", fnname = \"vrsraq_n_u8\", rettype = \"uint8x16_t\", argtypes = \"[uint8x16_t,uint8x16_t,__constrange(1,8) int]\", vals = [VectorVal [IntegerVal 255,IntegerVal 241,IntegerVal 127,IntegerVal 128,IntegerVal 32,IntegerVal 153,IntegerVal 127,IntegerVal 0,IntegerVal 0,IntegerVal 127,IntegerVal 128,IntegerVal 128,IntegerVal 127,IntegerVal 128,IntegerVal 80,IntegerVal 127],VectorVal [IntegerVal 36,IntegerVal 255,IntegerVal 223,IntegerVal 128,IntegerVal 128,IntegerVal 127,IntegerVal 128,IntegerVal 47,IntegerVal 128,IntegerVal 63,IntegerVal 128,IntegerVal 216,IntegerVal 8,IntegerVal 255,IntegerVal 127,IntegerVal 128],IndexVal 1], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u8(vcreate_u8(UINT64_C(0x007f9920807ff1ff)),
                         vcreate_u8(UINT64_C(0x7f50807f80807f00)));
      arg2 = vcombine_u8(vcreate_u8(UINT64_C(0x2f807f8080dfff24)),
                         vcreate_u8(UINT64_C(0x807fff08d8803f80)));
      clear_neon_saturated();
      //  Expect: "result" = bf900083ecc09f4018bfd960c0ef7111
      result = vrsraq_n_u8(arg1, arg2, 1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 0);
         exp = UINT64_C(0x18bfd960c0ef7111);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 1);
         exp = UINT64_C(0xbf900083ecc09f40);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1007() {

{
   {
      uint16x8_t arg1;
      uint16x8_t arg2;
      uint16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"rsra\", fnname = \"vrsraq_n_u16\", rettype = \"uint16x8_t\", argtypes = \"[uint16x8_t,uint16x8_t,__constrange(1,16) int]\", vals = [VectorVal [IntegerVal 32768,IntegerVal 33341,IntegerVal 32768,IntegerVal 42116,IntegerVal 32768,IntegerVal 10842,IntegerVal 36788,IntegerVal 65535],VectorVal [IntegerVal 32768,IntegerVal 7162,IntegerVal 32767,IntegerVal 65535,IntegerVal 59601,IntegerVal 0,IntegerVal 65535,IntegerVal 54476],IndexVal 1], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u16(vcreate_u16(UINT64_C(0xa4848000823d8000)),
                          vcreate_u16(UINT64_C(0xffff8fb42a5a8000)));
      arg2 = vcombine_u16(vcreate_u16(UINT64_C(0xffff7fff1bfa8000)),
                          vcreate_u16(UINT64_C(0xd4ccffff0000e8d1)));
      clear_neon_saturated();
      //  Expect: "result" = 6a650fb42a5af4692484c000903ac000
      result = vrsraq_n_u16(arg1, arg2, 1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 0);
         exp = UINT64_C(0x2484c000903ac000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 1);
         exp = UINT64_C(0x6a650fb42a5af469);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1008() {

{
   {
      uint32x4_t arg1;
      uint32x4_t arg2;
      uint32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"rsra\", fnname = \"vrsraq_n_u32\", rettype = \"uint32x4_t\", argtypes = \"[uint32x4_t,uint32x4_t,__constrange(1,32) int]\", vals = [VectorVal [IntegerVal 0,IntegerVal 2147483647,IntegerVal 2147516415,IntegerVal 4279599103],VectorVal [IntegerVal 2147516416,IntegerVal 2147450879,IntegerVal 2147483648,IntegerVal 2147451657],IndexVal 22], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u32(vcreate_u32(UINT64_C(0x7fffffff00000000)),
                          vcreate_u32(UINT64_C(0xff157fff80007fff)));
      arg2 = vcombine_u32(vcreate_u32(UINT64_C(0x7fff7fff80008000)),
                          vcreate_u32(UINT64_C(0x7fff830980000000)));
      clear_neon_saturated();
      //  Expect: "result" = ff1581ff800081ff800001ff00000200
      result = vrsraq_n_u32(arg1, arg2, 22);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 0);
         exp = UINT64_C(0x800001ff00000200);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 1);
         exp = UINT64_C(0xff1581ff800081ff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1009() {

{
   {
      uint64x2_t arg1;
      uint64x2_t arg2;
      uint64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"rsra\", fnname = \"vrsraq_n_u64\", rettype = \"uint64x2_t\", argtypes = \"[uint64x2_t,uint64x2_t,__constrange(1,64) int]\", vals = [VectorVal [IntegerVal 281472829259776,IntegerVal 18446744071562100736],VectorVal [IntegerVal 140739635838976,IntegerVal 18107848203897438208],IndexVal 58], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u64(vcreate_u64(UINT64_C(0x0000ffff80008000)),
                          vcreate_u64(UINT64_C(0xffffffff80008000)));
      arg2 = vcombine_u64(vcreate_u64(UINT64_C(0x0000800080000000)),
                          vcreate_u64(UINT64_C(0xfb4c000080008000)));
      clear_neon_saturated();
      //  Expect: "result" = ffffffff8000803f0000ffff80008000
      result = vrsraq_n_u64(arg1, arg2, 58);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 0);
         exp = UINT64_C(0x0000ffff80008000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 1);
         exp = UINT64_C(0xffffffff8000803f);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1010() {

{
   {
      int64_t arg1;
      int64_t arg2;
      int64_t result;
      char* str1 = "ReproInfo2 {semantics = \"rsra\", fnname = \"vrsrad_n_s64\", rettype = \"int64_t\", argtypes = \"[int64_t,int64_t,__constrange(1,64) int]\", vals = [IntegerVal (-9223090564025516032),IntegerVal 1451144242431787008,IndexVal 42], start_saturated = False}";
      int reported = 0;
      int64_t got;
      int64_t exp;
      arg1 = INT64_C(-9223090564025516032);
      arg2 = INT64_C(1451144242431787008);
      clear_neon_saturated();
      //  Expect: "result" = 8000ffff800588e0
      result = vrsrad_n_s64(arg1, arg2, 42);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = INT64_C(-9223090564025186080);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIi64 " Got: %" PRIi64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1011() {

{
   {
      uint64_t arg1;
      uint64_t arg2;
      uint64_t result;
      char* str1 = "ReproInfo2 {semantics = \"rsra\", fnname = \"vrsrad_n_u64\", rettype = \"uint64_t\", argtypes = \"[uint64_t,uint64_t,__constrange(1,64) int]\", vals = [IntegerVal 2823756970656202752,IntegerVal 9223343475322200738,IndexVal 54], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = UINT64_C(0x27300000ffff0000);
      arg2 = UINT64_C(0x7fffe605ffff22a2);
      clear_neon_saturated();
      //  Expect: "result" = 27300000ffff0200
      result = vrsrad_n_u64(arg1, arg2, 54);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = UINT64_C(0x27300000ffff0200);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1012() {

{
   {
      int8x8_t arg1;
      int8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"qshl\", fnname = \"vqshl_n_s8\", rettype = \"int8x8_t\", argtypes = \"[int8x8_t,__constrange(0,7) int]\", vals = [VectorVal [IntegerVal 127,IntegerVal (-128),IntegerVal 0,IntegerVal 2,IntegerVal (-1),IntegerVal (-128),IntegerVal 127,IntegerVal (-128)],IndexVal 0], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s8(UINT64_C(0x807f80ff0200807f));
      clear_neon_saturated();
      //  Expect: "result" = 807f80ff0200807f
      result = vqshl_n_s8(arg1, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s8(result), 0);
      exp = UINT64_C(0x807f80ff0200807f);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1013() {

{
   {
      int16x4_t arg1;
      int16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"qshl\", fnname = \"vqshl_n_s16\", rettype = \"int16x4_t\", argtypes = \"[int16x4_t,__constrange(0,15) int]\", vals = [VectorVal [IntegerVal 32767,IntegerVal 0,IntegerVal (-24044),IntegerVal 0],IndexVal 14], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s16(UINT64_C(0x0000a21400007fff));
      clear_neon_saturated();
      //  Expect: "result" = 0000800000007fff
      result = vqshl_n_s16(arg1, 14);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s16(result), 0);
      exp = UINT64_C(0x0000800000007fff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1014() {

{
   {
      int32x2_t arg1;
      int32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"qshl\", fnname = \"vqshl_n_s32\", rettype = \"int32x2_t\", argtypes = \"[int32x2_t,__constrange(0,31) int]\", vals = [VectorVal [IntegerVal (-1),IntegerVal (-1859059712)],IndexVal 10], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s32(UINT64_C(0x91310000ffffffff));
      clear_neon_saturated();
      //  Expect: "result" = 80000000fffffc00
      result = vqshl_n_s32(arg1, 10);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s32(result), 0);
      exp = UINT64_C(0x80000000fffffc00);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1015() {

{
   {
      int64x1_t arg1;
      int64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"qshl\", fnname = \"vqshl_n_s64\", rettype = \"int64x1_t\", argtypes = \"[int64x1_t,__constrange(0,63) int]\", vals = [VectorVal [IntegerVal (-158965329592321)],IndexVal 52], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s64(UINT64_C(0xffff6f6bffff7fff));
      clear_neon_saturated();
      //  Expect: "result" = 8000000000000000
      result = vqshl_n_s64(arg1, 52);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s64(result), 0);
      exp = UINT64_C(0x8000000000000000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1016() {

{
   {
      uint8x8_t arg1;
      uint8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"qshl\", fnname = \"vqshl_n_u8\", rettype = \"uint8x8_t\", argtypes = \"[uint8x8_t,__constrange(0,7) int]\", vals = [VectorVal [IntegerVal 128,IntegerVal 128,IntegerVal 255,IntegerVal 47,IntegerVal 128,IntegerVal 127,IntegerVal 127,IntegerVal 127],IndexVal 7], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u8(UINT64_C(0x7f7f7f802fff8080));
      clear_neon_saturated();
      //  Expect: "result" = ffffffffffffffff
      result = vqshl_n_u8(arg1, 7);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u8(result), 0);
      exp = UINT64_C(0xffffffffffffffff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1017() {

{
   {
      uint16x4_t arg1;
      uint16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"qshl\", fnname = \"vqshl_n_u16\", rettype = \"uint16x4_t\", argtypes = \"[uint16x4_t,__constrange(0,15) int]\", vals = [VectorVal [IntegerVal 32767,IntegerVal 65535,IntegerVal 32768,IntegerVal 65535],IndexVal 14], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u16(UINT64_C(0xffff8000ffff7fff));
      clear_neon_saturated();
      //  Expect: "result" = ffffffffffffffff
      result = vqshl_n_u16(arg1, 14);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u16(result), 0);
      exp = UINT64_C(0xffffffffffffffff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1018() {

{
   {
      uint32x2_t arg1;
      uint32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"qshl\", fnname = \"vqshl_n_u32\", rettype = \"uint32x2_t\", argtypes = \"[uint32x2_t,__constrange(0,31) int]\", vals = [VectorVal [IntegerVal 2147433450,IntegerVal 32175],IndexVal 26], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u32(UINT64_C(0x00007daf7fff3bea));
      clear_neon_saturated();
      //  Expect: "result" = ffffffffffffffff
      result = vqshl_n_u32(arg1, 26);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u32(result), 0);
      exp = UINT64_C(0xffffffffffffffff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1019() {

{
   {
      uint64x1_t arg1;
      uint64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"qshl\", fnname = \"vqshl_n_u64\", rettype = \"uint64x1_t\", argtypes = \"[uint64x1_t,__constrange(0,63) int]\", vals = [VectorVal [IntegerVal 18446603336221163520],IndexVal 12], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u64(UINT64_C(0xffff7fffffff8000));
      clear_neon_saturated();
      //  Expect: "result" = ffffffffffffffff
      result = vqshl_n_u64(arg1, 12);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      got = vget_lane_u64(result, 0);
      exp = UINT64_C(0xffffffffffffffff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1020() {

{
   {
      int8x16_t arg1;
      int8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"qshl\", fnname = \"vqshlq_n_s8\", rettype = \"int8x16_t\", argtypes = \"[int8x16_t,__constrange(0,7) int]\", vals = [VectorVal [IntegerVal 0,IntegerVal (-1),IntegerVal 102,IntegerVal (-1),IntegerVal 42,IntegerVal 9,IntegerVal 127,IntegerVal 99,IntegerVal (-128),IntegerVal (-128),IntegerVal 0,IntegerVal 0,IntegerVal (-109),IntegerVal 96,IntegerVal (-92),IntegerVal (-1)],IndexVal 3], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s8(vcreate_s8(UINT64_C(0x637f092aff66ff00)),
                         vcreate_s8(UINT64_C(0xffa4609300008080)));
      clear_neon_saturated();
      //  Expect: "result" = f8807f80000080807f7f487ff87ff800
      result = vqshlq_n_s8(arg1, 3);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result), 0);
         exp = UINT64_C(0x7f7f487ff87ff800);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result), 1);
         exp = UINT64_C(0xf8807f8000008080);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1021() {

{
   {
      int16x8_t arg1;
      int16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"qshl\", fnname = \"vqshlq_n_s16\", rettype = \"int16x8_t\", argtypes = \"[int16x8_t,__constrange(0,15) int]\", vals = [VectorVal [IntegerVal 0,IntegerVal (-12450),IntegerVal 0,IntegerVal (-7606),IntegerVal 32767,IntegerVal (-19277),IntegerVal 32688,IntegerVal (-32768)],IndexVal 14], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s16(vcreate_s16(UINT64_C(0xe24a0000cf5e0000)),
                          vcreate_s16(UINT64_C(0x80007fb0b4b37fff)));
      clear_neon_saturated();
      //  Expect: "result" = 80007fff80007fff8000000080000000
      result = vqshlq_n_s16(arg1, 14);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 0);
         exp = UINT64_C(0x8000000080000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 1);
         exp = UINT64_C(0x80007fff80007fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1022() {

{
   {
      int32x4_t arg1;
      int32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"qshl\", fnname = \"vqshlq_n_s32\", rettype = \"int32x4_t\", argtypes = \"[int32x4_t,__constrange(0,31) int]\", vals = [VectorVal [IntegerVal 2029322240,IntegerVal (-65536),IntegerVal 65535,IntegerVal 2147450879],IndexVal 7], start_saturated = True}";
      int reported = 0;
      arg1 = vcombine_s32(vcreate_s32(UINT64_C(0xffff000078f50000)),
                          vcreate_s32(UINT64_C(0x7fff7fff0000ffff)));
      set_neon_saturated();
      //  Expect: "result" = 7fffffff007fff80ff8000007fffffff
      result = vqshlq_n_s32(arg1, 7);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 0);
         exp = UINT64_C(0xff8000007fffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 1);
         exp = UINT64_C(0x7fffffff007fff80);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1023() {

{
   {
      int64x2_t arg1;
      int64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"qshl\", fnname = \"vqshlq_n_s64\", rettype = \"int64x2_t\", argtypes = \"[int64x2_t,__constrange(0,63) int]\", vals = [VectorVal [IntegerVal (-9223166099615416320),IntegerVal 3107624480373964799],IndexVal 0], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s64(vcreate_s64(UINT64_C(0x8000bb4c7fff8000)),
                          vcreate_s64(UINT64_C(0x2b207fffffff7fff)));
      clear_neon_saturated();
      //  Expect: "result" = 2b207fffffff7fff8000bb4c7fff8000
      result = vqshlq_n_s64(arg1, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 0);
         exp = UINT64_C(0x8000bb4c7fff8000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 1);
         exp = UINT64_C(0x2b207fffffff7fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1024() {

{
   {
      uint8x16_t arg1;
      uint8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"qshl\", fnname = \"vqshlq_n_u8\", rettype = \"uint8x16_t\", argtypes = \"[uint8x16_t,__constrange(0,7) int]\", vals = [VectorVal [IntegerVal 214,IntegerVal 0,IntegerVal 199,IntegerVal 127,IntegerVal 0,IntegerVal 255,IntegerVal 255,IntegerVal 128,IntegerVal 127,IntegerVal 197,IntegerVal 134,IntegerVal 0,IntegerVal 0,IntegerVal 255,IntegerVal 0,IntegerVal 22],IndexVal 4], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u8(vcreate_u8(UINT64_C(0x80ffff007fc700d6)),
                         vcreate_u8(UINT64_C(0x1600ff000086c57f)));
      clear_neon_saturated();
      //  Expect: "result" = ff00ff0000ffffffffffff00ffff00ff
      result = vqshlq_n_u8(arg1, 4);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 0);
         exp = UINT64_C(0xffffff00ffff00ff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 1);
         exp = UINT64_C(0xff00ff0000ffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1025() {

{
   {
      uint16x8_t arg1;
      uint16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"qshl\", fnname = \"vqshlq_n_u16\", rettype = \"uint16x8_t\", argtypes = \"[uint16x8_t,__constrange(0,15) int]\", vals = [VectorVal [IntegerVal 57671,IntegerVal 32768,IntegerVal 0,IntegerVal 32767,IntegerVal 65535,IntegerVal 32768,IntegerVal 65535,IntegerVal 65535],IndexVal 0], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u16(vcreate_u16(UINT64_C(0x7fff00008000e147)),
                          vcreate_u16(UINT64_C(0xffffffff8000ffff)));
      clear_neon_saturated();
      //  Expect: "result" = ffffffff8000ffff7fff00008000e147
      result = vqshlq_n_u16(arg1, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 0);
         exp = UINT64_C(0x7fff00008000e147);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 1);
         exp = UINT64_C(0xffffffff8000ffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1026() {

{
   {
      uint32x4_t arg1;
      uint32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"qshl\", fnname = \"vqshlq_n_u32\", rettype = \"uint32x4_t\", argtypes = \"[uint32x4_t,__constrange(0,31) int]\", vals = [VectorVal [IntegerVal 65535,IntegerVal 4294934528,IntegerVal 2147516416,IntegerVal 2145255423],IndexVal 9], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u32(vcreate_u32(UINT64_C(0xffff80000000ffff)),
                          vcreate_u32(UINT64_C(0x7fddffff80008000)));
      clear_neon_saturated();
      //  Expect: "result" = ffffffffffffffffffffffff01fffe00
      result = vqshlq_n_u32(arg1, 9);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 0);
         exp = UINT64_C(0xffffffff01fffe00);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 1);
         exp = UINT64_C(0xffffffffffffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1027() {

{
   {
      uint64x2_t arg1;
      uint64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"qshl\", fnname = \"vqshlq_n_u64\", rettype = \"uint64x2_t\", argtypes = \"[uint64x2_t,__constrange(0,63) int]\", vals = [VectorVal [IntegerVal 2147483648,IntegerVal 9223481749646869140],IndexVal 50], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u64(vcreate_u64(UINT64_C(0x0000000080000000)),
                          vcreate_u64(UINT64_C(0x800063c880000294)));
      clear_neon_saturated();
      //  Expect: "result" = ffffffffffffffffffffffffffffffff
      result = vqshlq_n_u64(arg1, 50);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 0);
         exp = UINT64_C(0xffffffffffffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 1);
         exp = UINT64_C(0xffffffffffffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1028() {

{
   {
      int8_t arg1;
      int8_t result;
      char* str1 = "ReproInfo2 {semantics = \"qshl\", fnname = \"vqshlb_n_s8\", rettype = \"int8_t\", argtypes = \"[int8_t,__constrange(0,7) int]\", vals = [IntegerVal (-128),IndexVal 3], start_saturated = False}";
      int reported = 0;
      int8_t got;
      int8_t exp;
      arg1 = -128;
      clear_neon_saturated();
      //  Expect: "result" = 80
      result = vqshlb_n_s8(arg1, 3);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      got = result;
      exp = -128;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1029() {

{
   {
      int16_t arg1;
      int16_t result;
      char* str1 = "ReproInfo2 {semantics = \"qshl\", fnname = \"vqshlh_n_s16\", rettype = \"int16_t\", argtypes = \"[int16_t,__constrange(0,15) int]\", vals = [IntegerVal 0,IndexVal 6], start_saturated = False}";
      int reported = 0;
      int16_t got;
      int16_t exp;
      arg1 = 0;
      clear_neon_saturated();
      //  Expect: "result" = 0000
      result = vqshlh_n_s16(arg1, 6);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = 0;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIi16 " Got: %" PRIi16 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1030() {

{
   {
      int32_t arg1;
      int32_t result;
      char* str1 = "ReproInfo2 {semantics = \"qshl\", fnname = \"vqshls_n_s32\", rettype = \"int32_t\", argtypes = \"[int32_t,__constrange(0,31) int]\", vals = [IntegerVal 2147450879,IndexVal 24], start_saturated = False}";
      int reported = 0;
      int32_t got;
      int32_t exp;
      arg1 = 2147450879;
      clear_neon_saturated();
      //  Expect: "result" = 7fffffff
      result = vqshls_n_s32(arg1, 24);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      got = result;
      exp = 2147483647;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIi32 " Got: %" PRIi32 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1031() {

{
   {
      int64_t arg1;
      int64_t result;
      char* str1 = "ReproInfo2 {semantics = \"qshl\", fnname = \"vqshld_n_s64\", rettype = \"int64_t\", argtypes = \"[int64_t,__constrange(0,63) int]\", vals = [IntegerVal 9223231301023072256,IndexVal 29], start_saturated = False}";
      int reported = 0;
      int64_t got;
      int64_t exp;
      arg1 = INT64_C(9223231301023072256);
      clear_neon_saturated();
      //  Expect: "result" = 7fffffffffffffff
      result = vqshld_n_s64(arg1, 29);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      got = result;
      exp = INT64_C(9223372036854775807);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIi64 " Got: %" PRIi64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1032() {

{
   {
      uint8_t arg1;
      uint8_t result;
      char* str1 = "ReproInfo2 {semantics = \"qshl\", fnname = \"vqshlb_n_u8\", rettype = \"uint8_t\", argtypes = \"[uint8_t,__constrange(0,7) int]\", vals = [IntegerVal 127,IndexVal 5], start_saturated = False}";
      int reported = 0;
      uint8_t got;
      uint8_t exp;
      arg1 = 127U;
      clear_neon_saturated();
      //  Expect: "result" = ff
      result = vqshlb_n_u8(arg1, 5);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      got = result;
      exp = 255U;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1033() {

{
   {
      uint16_t arg1;
      uint16_t result;
      char* str1 = "ReproInfo2 {semantics = \"qshl\", fnname = \"vqshlh_n_u16\", rettype = \"uint16_t\", argtypes = \"[uint16_t,__constrange(0,15) int]\", vals = [IntegerVal 0,IndexVal 3], start_saturated = False}";
      int reported = 0;
      uint16_t got;
      uint16_t exp;
      arg1 = 0;
      clear_neon_saturated();
      //  Expect: "result" = 0000
      result = vqshlh_n_u16(arg1, 3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = 0;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1034() {

{
   {
      uint32_t arg1;
      uint32_t result;
      char* str1 = "ReproInfo2 {semantics = \"qshl\", fnname = \"vqshls_n_u32\", rettype = \"uint32_t\", argtypes = \"[uint32_t,__constrange(0,31) int]\", vals = [IntegerVal 4294934528,IndexVal 23], start_saturated = False}";
      int reported = 0;
      uint32_t got;
      uint32_t exp;
      arg1 = 4294934528U;
      clear_neon_saturated();
      //  Expect: "result" = ffffffff
      result = vqshls_n_u32(arg1, 23);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      got = result;
      exp = 4294967295U;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIu32 " Got: %" PRIu32 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1035() {

{
   {
      uint64_t arg1;
      uint64_t result;
      char* str1 = "ReproInfo2 {semantics = \"qshl\", fnname = \"vqshld_n_u64\", rettype = \"uint64_t\", argtypes = \"[uint64_t,__constrange(0,63) int]\", vals = [IntegerVal 10866622949274583040,IndexVal 14], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = UINT64_C(0x96cdffff9f9e8000);
      clear_neon_saturated();
      //  Expect: "result" = ffffffffffffffff
      result = vqshld_n_u64(arg1, 14);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      got = result;
      exp = UINT64_C(0xffffffffffffffff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1036() {

{
   {
      int8x8_t arg1;
      uint8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"qshl\", fnname = \"vqshlu_n_s8\", rettype = \"uint8x8_t\", argtypes = \"[int8x8_t,__constrange(0,7) int]\", vals = [VectorVal [IntegerVal (-91),IntegerVal (-128),IntegerVal 127,IntegerVal 101,IntegerVal 127,IntegerVal 0,IntegerVal (-115),IntegerVal (-83)],IndexVal 4], start_saturated = True}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s8(UINT64_C(0xad8d007f657f80a5));
      set_neon_saturated();
      //  Expect: "result" = 000000ffffff0000
      result = vqshlu_n_s8(arg1, 4);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u8(result), 0);
      exp = UINT64_C(0x000000ffffff0000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1037() {

{
   {
      int16x4_t arg1;
      uint16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"qshl\", fnname = \"vqshlu_n_s16\", rettype = \"uint16x4_t\", argtypes = \"[int16x4_t,__constrange(0,15) int]\", vals = [VectorVal [IntegerVal (-1),IntegerVal (-32768),IntegerVal 0,IntegerVal 32767],IndexVal 11], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s16(UINT64_C(0x7fff00008000ffff));
      clear_neon_saturated();
      //  Expect: "result" = ffff000000000000
      result = vqshlu_n_s16(arg1, 11);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u16(result), 0);
      exp = UINT64_C(0xffff000000000000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1038() {

{
   {
      int32x2_t arg1;
      uint32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"qshl\", fnname = \"vqshlu_n_s32\", rettype = \"uint32x2_t\", argtypes = \"[int32x2_t,__constrange(0,31) int]\", vals = [VectorVal [IntegerVal 2147483647,IntegerVal (-1245020161)],IndexVal 4], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s32(UINT64_C(0xb5ca7fff7fffffff));
      clear_neon_saturated();
      //  Expect: "result" = 00000000ffffffff
      result = vqshlu_n_s32(arg1, 4);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u32(result), 0);
      exp = UINT64_C(0x00000000ffffffff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1039() {

{
   {
      int64x1_t arg1;
      uint64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"qshl\", fnname = \"vqshlu_n_s64\", rettype = \"uint64x1_t\", argtypes = \"[int64x1_t,__constrange(0,63) int]\", vals = [VectorVal [IntegerVal (-4294934529)],IndexVal 48], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s64(UINT64_C(0xffffffff00007fff));
      clear_neon_saturated();
      //  Expect: "result" = 0000000000000000
      result = vqshlu_n_s64(arg1, 48);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      got = vget_lane_u64(result, 0);
      exp = 0;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1040() {

{
   {
      int8x16_t arg1;
      uint8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"qshl\", fnname = \"vqshluq_n_s8\", rettype = \"uint8x16_t\", argtypes = \"[int8x16_t,__constrange(0,7) int]\", vals = [VectorVal [IntegerVal 127,IntegerVal (-128),IntegerVal (-74),IntegerVal (-1),IntegerVal (-128),IntegerVal 127,IntegerVal (-1),IntegerVal 85,IntegerVal (-1),IntegerVal (-73),IntegerVal 0,IntegerVal (-1),IntegerVal 127,IntegerVal (-101),IntegerVal (-128),IntegerVal 127],IndexVal 6], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s8(vcreate_s8(UINT64_C(0x55ff7f80ffb6807f)),
                         vcreate_s8(UINT64_C(0x7f809b7fff00b7ff)));
      clear_neon_saturated();
      //  Expect: "result" = ff0000ff00000000ff00ff00000000ff
      result = vqshluq_n_s8(arg1, 6);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 0);
         exp = UINT64_C(0xff00ff00000000ff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 1);
         exp = UINT64_C(0xff0000ff00000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1041() {

{
   {
      int16x8_t arg1;
      uint16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"qshl\", fnname = \"vqshluq_n_s16\", rettype = \"uint16x8_t\", argtypes = \"[int16x8_t,__constrange(0,15) int]\", vals = [VectorVal [IntegerVal 0,IntegerVal 3471,IntegerVal 0,IntegerVal 32767,IntegerVal 0,IntegerVal 0,IntegerVal (-1),IntegerVal 17332],IndexVal 15], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s16(vcreate_s16(UINT64_C(0x7fff00000d8f0000)),
                          vcreate_s16(UINT64_C(0x43b4ffff00000000)));
      clear_neon_saturated();
      //  Expect: "result" = ffff000000000000ffff0000ffff0000
      result = vqshluq_n_s16(arg1, 15);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 0);
         exp = UINT64_C(0xffff0000ffff0000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 1);
         exp = UINT64_C(0xffff000000000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1042() {

{
   {
      int32x4_t arg1;
      uint32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"qshl\", fnname = \"vqshluq_n_s32\", rettype = \"uint32x4_t\", argtypes = \"[int32x4_t,__constrange(0,31) int]\", vals = [VectorVal [IntegerVal 2147450879,IntegerVal (-2147450881),IntegerVal 2147483647,IntegerVal (-2147453615)],IndexVal 1], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s32(vcreate_s32(UINT64_C(0x80007fff7fff7fff)),
                          vcreate_s32(UINT64_C(0x800075517fffffff)));
      clear_neon_saturated();
      //  Expect: "result" = 00000000fffffffe00000000fffefffe
      result = vqshluq_n_s32(arg1, 1);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 0);
         exp = UINT64_C(0x00000000fffefffe);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 1);
         exp = UINT64_C(0x00000000fffffffe);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1043() {

{
   {
      int64x2_t arg1;
      uint64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"qshl\", fnname = \"vqshluq_n_s64\", rettype = \"uint64x2_t\", argtypes = \"[int64x2_t,__constrange(0,63) int]\", vals = [VectorVal [IntegerVal (-144602958902217),IntegerVal (-281472829227008)],IndexVal 25], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s64(vcreate_s64(UINT64_C(0xffff7c7c00004c37)),
                          vcreate_s64(UINT64_C(0xffff000080000000)));
      clear_neon_saturated();
      //  Expect: "result" = 00000000000000000000000000000000
      result = vqshluq_n_s64(arg1, 25);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 0);
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 1);
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1044() {

{
   {
      int8_t arg1;
      uint8_t result;
      char* str1 = "ReproInfo2 {semantics = \"qshl\", fnname = \"vqshlub_n_s8\", rettype = \"uint8_t\", argtypes = \"[int8_t,__constrange(0,7) int]\", vals = [IntegerVal (-1),IndexVal 2], start_saturated = False}";
      int reported = 0;
      uint8_t got;
      uint8_t exp;
      arg1 = -1;
      clear_neon_saturated();
      //  Expect: "result" = 00
      result = vqshlub_n_s8(arg1, 2);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      got = result;
      exp = 0;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1045() {

{
   {
      int16_t arg1;
      uint16_t result;
      char* str1 = "ReproInfo2 {semantics = \"qshl\", fnname = \"vqshluh_n_s16\", rettype = \"uint16_t\", argtypes = \"[int16_t,__constrange(0,15) int]\", vals = [IntegerVal 31575,IndexVal 2], start_saturated = False}";
      int reported = 0;
      uint16_t got;
      uint16_t exp;
      arg1 = 31575;
      clear_neon_saturated();
      //  Expect: "result" = ffff
      result = vqshluh_n_s16(arg1, 2);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      got = result;
      exp = 65535U;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1046() {

{
   {
      int32_t arg1;
      uint32_t result;
      char* str1 = "ReproInfo2 {semantics = \"qshl\", fnname = \"vqshlus_n_s32\", rettype = \"uint32_t\", argtypes = \"[int32_t,__constrange(0,31) int]\", vals = [IntegerVal (-564527104),IndexVal 26], start_saturated = False}";
      int reported = 0;
      uint32_t got;
      uint32_t exp;
      arg1 = -564527104;
      clear_neon_saturated();
      //  Expect: "result" = 00000000
      result = vqshlus_n_s32(arg1, 26);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      got = result;
      exp = 0;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIu32 " Got: %" PRIu32 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1047() {

{
   {
      int64_t arg1;
      uint64_t result;
      char* str1 = "ReproInfo2 {semantics = \"qshl\", fnname = \"vqshlud_n_s64\", rettype = \"uint64_t\", argtypes = \"[int64_t,__constrange(0,63) int]\", vals = [IntegerVal 9223231297366163455,IndexVal 36], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = INT64_C(9223231297366163455);
      clear_neon_saturated();
      //  Expect: "result" = ffffffffffffffff
      result = vqshlud_n_s64(arg1, 36);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      got = result;
      exp = UINT64_C(0xffffffffffffffff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1048() {

{
   {
      int16x8_t arg1;
      int8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"shr\", fnname = \"vshrn_n_s16\", rettype = \"int8x8_t\", argtypes = \"[int16x8_t,__constrange(1,8) int]\", vals = [VectorVal [IntegerVal (-12843),IntegerVal (-1),IntegerVal 32767,IntegerVal 32767,IntegerVal 32767,IntegerVal (-1),IntegerVal 15979,IntegerVal (-16053)],IndexVal 6], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcombine_s16(vcreate_s16(UINT64_C(0x7fff7fffffffcdd5)),
                          vcreate_s16(UINT64_C(0xc14b3e6bffff7fff)));
      clear_neon_saturated();
      //  Expect: "result" = 05f9ffffffffff37
      result = vshrn_n_s16(arg1, 6);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s8(result), 0);
      exp = UINT64_C(0x05f9ffffffffff37);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1049() {

{
   {
      int32x4_t arg1;
      int16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"shr\", fnname = \"vshrn_n_s32\", rettype = \"int16x4_t\", argtypes = \"[int32x4_t,__constrange(1,16) int]\", vals = [VectorVal [IntegerVal (-65536),IntegerVal (-6240),IntegerVal (-1),IntegerVal 1420394496],IndexVal 15], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcombine_s32(vcreate_s32(UINT64_C(0xffffe7a0ffff0000)),
                          vcreate_s32(UINT64_C(0x54a98000ffffffff)));
      clear_neon_saturated();
      //  Expect: "result" = a953fffffffffffe
      result = vshrn_n_s32(arg1, 15);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s16(result), 0);
      exp = UINT64_C(0xa953fffffffffffe);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1050() {

{
   {
      int64x2_t arg1;
      int32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"shr\", fnname = \"vshrn_n_s64\", rettype = \"int32x2_t\", argtypes = \"[int64x2_t,__constrange(1,32) int]\", vals = [VectorVal [IntegerVal 9223231301513936896,IntegerVal 140736164167679],IndexVal 2], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcombine_s64(vcreate_s64(UINT64_C(0x7fff800080008000)),
                          vcreate_s64(UINT64_C(0x00007fffb1127fff)));
      clear_neon_saturated();
      //  Expect: "result" = ec449fff20002000
      result = vshrn_n_s64(arg1, 2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s32(result), 0);
      exp = UINT64_C(0xec449fff20002000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1051() {

{
   {
      uint16x8_t arg1;
      uint8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"shr\", fnname = \"vshrn_n_u16\", rettype = \"uint8x8_t\", argtypes = \"[uint16x8_t,__constrange(1,8) int]\", vals = [VectorVal [IntegerVal 0,IntegerVal 32767,IntegerVal 65535,IntegerVal 0,IntegerVal 65535,IntegerVal 7637,IntegerVal 44191,IntegerVal 65535],IndexVal 6], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcombine_u16(vcreate_u16(UINT64_C(0x0000ffff7fff0000)),
                          vcreate_u16(UINT64_C(0xffffac9f1dd5ffff)));
      clear_neon_saturated();
      //  Expect: "result" = ffb277ff00ffff00
      result = vshrn_n_u16(arg1, 6);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u8(result), 0);
      exp = UINT64_C(0xffb277ff00ffff00);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1052() {

{
   {
      uint32x4_t arg1;
      uint16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"shr\", fnname = \"vshrn_n_u32\", rettype = \"uint16x4_t\", argtypes = \"[uint32x4_t,__constrange(1,16) int]\", vals = [VectorVal [IntegerVal 2147450880,IntegerVal 3983212543,IntegerVal 32767,IntegerVal 2147450879],IndexVal 14], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcombine_u32(vcreate_u32(UINT64_C(0xed6affff7fff8000)),
                          vcreate_u32(UINT64_C(0x7fff7fff00007fff)));
      clear_neon_saturated();
      //  Expect: "result" = fffd0001b5abfffe
      result = vshrn_n_u32(arg1, 14);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u16(result), 0);
      exp = UINT64_C(0xfffd0001b5abfffe);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1053() {

{
   {
      uint64x2_t arg1;
      uint32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"shr\", fnname = \"vshrn_n_u64\", rettype = \"uint32x2_t\", argtypes = \"[uint64x2_t,__constrange(1,32) int]\", vals = [VectorVal [IntegerVal 9223653507536519168,IntegerVal 9223512770048229375],IndexVal 20], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcombine_u64(vcreate_u64(UINT64_C(0x8000ffff00000000)),
                          vcreate_u64(UINT64_C(0x80007fff0000ffff)));
      clear_neon_saturated();
      //  Expect: "result" = 07fff0000ffff000
      result = vshrn_n_u64(arg1, 20);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u32(result), 0);
      exp = UINT64_C(0x07fff0000ffff000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1054() {

{
   {
      int8x8_t arg1;
      int16x8_t arg2;
      int8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"shr\", fnname = \"vshrn_high_n_s16\", rettype = \"int8x16_t\", argtypes = \"[int8x8_t,int16x8_t,__constrange(1,8) int]\", vals = [VectorVal [IntegerVal (-128),IntegerVal (-1),IntegerVal (-92),IntegerVal 61,IntegerVal 127,IntegerVal (-128),IntegerVal 127,IntegerVal (-128)],VectorVal [IntegerVal (-32768),IntegerVal 0,IntegerVal (-32768),IntegerVal 32767,IntegerVal (-32768),IntegerVal 0,IntegerVal (-23802),IntegerVal 32767],IndexVal 5], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_s8(UINT64_C(0x807f807f3da4ff80));
      arg2 = vcombine_s16(vcreate_s16(UINT64_C(0x7fff800000008000)),
                          vcreate_s16(UINT64_C(0x7fffa30600008000)));
      clear_neon_saturated();
      //  Expect: "result" = ff180000ff000000807f807f3da4ff80
      result = vshrn_high_n_s16(arg1, arg2, 5);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result), 0);
         exp = UINT64_C(0x807f807f3da4ff80);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result), 1);
         exp = UINT64_C(0xff180000ff000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1055() {

{
   {
      int16x4_t arg1;
      int32x4_t arg2;
      int16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"shr\", fnname = \"vshrn_high_n_s32\", rettype = \"int16x8_t\", argtypes = \"[int16x4_t,int32x4_t,__constrange(1,16) int]\", vals = [VectorVal [IntegerVal 28204,IntegerVal (-1),IntegerVal (-1),IntegerVal 0],VectorVal [IntegerVal (-32768),IntegerVal 32768,IntegerVal 2147450879,IntegerVal (-32768)],IndexVal 2], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_s16(UINT64_C(0x0000ffffffff6e2c));
      arg2 = vcombine_s32(vcreate_s32(UINT64_C(0x00008000ffff8000)),
                          vcreate_s32(UINT64_C(0xffff80007fff7fff)));
      clear_neon_saturated();
      //  Expect: "result" = e000dfff2000e0000000ffffffff6e2c
      result = vshrn_high_n_s32(arg1, arg2, 2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 0);
         exp = UINT64_C(0x0000ffffffff6e2c);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 1);
         exp = UINT64_C(0xe000dfff2000e000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1056() {

{
   {
      int32x2_t arg1;
      int64x2_t arg2;
      int32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"shr\", fnname = \"vshrn_high_n_s64\", rettype = \"int32x4_t\", argtypes = \"[int32x2_t,int64x2_t,__constrange(1,32) int]\", vals = [VectorVal [IntegerVal (-1019314177),IntegerVal (-2147450880)],VectorVal [IntegerVal 9223090561878103373,IntegerVal 9223090564587683840],IndexVal 22], start_saturated = True}";
      int reported = 0;
      arg1 = vcreate_s32(UINT64_C(0x80008000c33e7fff));
      arg2 = vcombine_s64(vcreate_s64(UINT64_C(0x7fff00000000954d)),
                          vcreate_s64(UINT64_C(0x7fff0000a1818000)));
      set_neon_saturated();
      //  Expect: "result" = fc000286fc00000080008000c33e7fff
      result = vshrn_high_n_s64(arg1, arg2, 22);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 0);
         exp = UINT64_C(0x80008000c33e7fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 1);
         exp = UINT64_C(0xfc000286fc000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1057() {

{
   {
      uint8x8_t arg1;
      uint16x8_t arg2;
      uint8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"shr\", fnname = \"vshrn_high_n_u16\", rettype = \"uint8x16_t\", argtypes = \"[uint8x8_t,uint16x8_t,__constrange(1,8) int]\", vals = [VectorVal [IntegerVal 128,IntegerVal 128,IntegerVal 146,IntegerVal 255,IntegerVal 0,IntegerVal 255,IntegerVal 128,IntegerVal 0],VectorVal [IntegerVal 0,IntegerVal 47237,IntegerVal 32768,IntegerVal 22635,IntegerVal 45851,IntegerVal 32767,IntegerVal 0,IntegerVal 27249],IndexVal 5], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_u8(UINT64_C(0x0080ff00ff928080));
      arg2 = vcombine_u16(vcreate_u16(UINT64_C(0x586b8000b8850000)),
                          vcreate_u16(UINT64_C(0x6a7100007fffb31b)));
      clear_neon_saturated();
      //  Expect: "result" = 5300ff98c300c4000080ff00ff928080
      result = vshrn_high_n_u16(arg1, arg2, 5);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 0);
         exp = UINT64_C(0x0080ff00ff928080);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 1);
         exp = UINT64_C(0x5300ff98c300c400);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1058() {

{
   {
      uint16x4_t arg1;
      uint32x4_t arg2;
      uint16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"shr\", fnname = \"vshrn_high_n_u32\", rettype = \"uint16x8_t\", argtypes = \"[uint16x4_t,uint32x4_t,__constrange(1,16) int]\", vals = [VectorVal [IntegerVal 34311,IntegerVal 0,IntegerVal 65535,IntegerVal 0],VectorVal [IntegerVal 4294924743,IntegerVal 32768,IntegerVal 2147418112,IntegerVal 2147483647],IndexVal 9], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_u16(UINT64_C(0x0000ffff00008607));
      arg2 = vcombine_u32(vcreate_u32(UINT64_C(0x00008000ffff59c7)),
                          vcreate_u32(UINT64_C(0x7fffffff7fff0000)));
      clear_neon_saturated();
      //  Expect: "result" = ffffff800040ffac0000ffff00008607
      result = vshrn_high_n_u32(arg1, arg2, 9);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 0);
         exp = UINT64_C(0x0000ffff00008607);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 1);
         exp = UINT64_C(0xffffff800040ffac);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1059() {

{
   {
      uint32x2_t arg1;
      uint64x2_t arg2;
      uint32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"shr\", fnname = \"vshrn_high_n_u64\", rettype = \"uint32x4_t\", argtypes = \"[uint32x2_t,uint64x2_t,__constrange(1,32) int]\", vals = [VectorVal [IntegerVal 2147549183,IntegerVal 2147450879],VectorVal [IntegerVal 18446483480863834112,IntegerVal 9223512772195614720],IndexVal 3], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_u32(UINT64_C(0x7fff7fff8000ffff));
      arg2 = vcombine_u64(vcreate_u64(UINT64_C(0xffff12fe00000000)),
                          vcreate_u64(UINT64_C(0x80007fff7fff8000)));
      clear_neon_saturated();
      //  Expect: "result" = effff000c00000007fff7fff8000ffff
      result = vshrn_high_n_u64(arg1, arg2, 3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 0);
         exp = UINT64_C(0x7fff7fff8000ffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 1);
         exp = UINT64_C(0xeffff000c0000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1060() {

{
   {
      int16x8_t arg1;
      uint8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"qshr\", fnname = \"vqshrun_n_s16\", rettype = \"uint8x8_t\", argtypes = \"[int16x8_t,__constrange(1,8) int]\", vals = [VectorVal [IntegerVal 32767,IntegerVal (-1),IntegerVal (-32768),IntegerVal 0,IntegerVal 0,IntegerVal 32767,IntegerVal 0,IntegerVal 3614],IndexVal 3], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcombine_s16(vcreate_s16(UINT64_C(0x00008000ffff7fff)),
                          vcreate_s16(UINT64_C(0x0e1e00007fff0000)));
      clear_neon_saturated();
      //  Expect: "result" = ff00ff00000000ff
      result = vqshrun_n_s16(arg1, 3);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u8(result), 0);
      exp = UINT64_C(0xff00ff00000000ff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1061() {

{
   {
      int32x4_t arg1;
      uint16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"qshr\", fnname = \"vqshrun_n_s32\", rettype = \"uint16x4_t\", argtypes = \"[int32x4_t,__constrange(1,16) int]\", vals = [VectorVal [IntegerVal (-2147450880),IntegerVal (-1157267456),IntegerVal 2147418112,IntegerVal (-2147454383)],IndexVal 5], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcombine_s32(vcreate_s32(UINT64_C(0xbb05800080008000)),
                          vcreate_s32(UINT64_C(0x800072517fff0000)));
      clear_neon_saturated();
      //  Expect: "result" = 0000ffff00000000
      result = vqshrun_n_s32(arg1, 5);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u16(result), 0);
      exp = UINT64_C(0x0000ffff00000000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1062() {

{
   {
      int64x2_t arg1;
      uint32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"qshr\", fnname = \"vqshrun_n_s64\", rettype = \"uint32x2_t\", argtypes = \"[int64x2_t,__constrange(1,32) int]\", vals = [VectorVal [IntegerVal (-9223231303620591616),IntegerVal 9223231295071485952],IndexVal 3], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcombine_s64(vcreate_s64(UINT64_C(0x80007fff026e8000)),
                          vcreate_s64(UINT64_C(0x7fff7fff00008000)));
      clear_neon_saturated();
      //  Expect: "result" = ffffffff00000000
      result = vqshrun_n_s64(arg1, 3);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u32(result), 0);
      exp = UINT64_C(0xffffffff00000000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1063() {

{
   {
      int16_t arg1;
      uint8_t result;
      char* str1 = "ReproInfo2 {semantics = \"qshr\", fnname = \"vqshrunh_n_s16\", rettype = \"uint8_t\", argtypes = \"[int16_t,__constrange(1,8) int]\", vals = [IntegerVal (-7368),IndexVal 3], start_saturated = False}";
      int reported = 0;
      uint8_t got;
      uint8_t exp;
      arg1 = -7368;
      clear_neon_saturated();
      //  Expect: "result" = 00
      result = vqshrunh_n_s16(arg1, 3);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      got = result;
      exp = 0;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1064() {

{
   {
      int32_t arg1;
      uint16_t result;
      char* str1 = "ReproInfo2 {semantics = \"qshr\", fnname = \"vqshruns_n_s32\", rettype = \"uint16_t\", argtypes = \"[int32_t,__constrange(1,16) int]\", vals = [IntegerVal 2147450880,IndexVal 13], start_saturated = False}";
      int reported = 0;
      uint16_t got;
      uint16_t exp;
      arg1 = 2147450880;
      clear_neon_saturated();
      //  Expect: "result" = ffff
      result = vqshruns_n_s32(arg1, 13);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      got = result;
      exp = 65535U;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1065() {

{
   {
      int64_t arg1;
      uint32_t result;
      char* str1 = "ReproInfo2 {semantics = \"qshr\", fnname = \"vqshrund_n_s64\", rettype = \"uint32_t\", argtypes = \"[int64_t,__constrange(1,32) int]\", vals = [IntegerVal 9223090561878065152,IndexVal 22], start_saturated = False}";
      int reported = 0;
      uint32_t got;
      uint32_t exp;
      arg1 = INT64_C(9223090561878065152);
      clear_neon_saturated();
      //  Expect: "result" = ffffffff
      result = vqshrund_n_s64(arg1, 22);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      got = result;
      exp = 4294967295U;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIu32 " Got: %" PRIu32 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1066() {

{
   {
      uint8x8_t arg1;
      int16x8_t arg2;
      uint8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"qshr\", fnname = \"vqshrun_high_n_s16\", rettype = \"uint8x16_t\", argtypes = \"[uint8x8_t,int16x8_t,__constrange(1,8) int]\", vals = [VectorVal [IntegerVal 127,IntegerVal 0,IntegerVal 128,IntegerVal 255,IntegerVal 255,IntegerVal 128,IntegerVal 75,IntegerVal 0],VectorVal [IntegerVal (-20804),IntegerVal (-32768),IntegerVal 0,IntegerVal 32767,IntegerVal 32767,IntegerVal 6387,IntegerVal 32767,IntegerVal (-32768)],IndexVal 3], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_u8(UINT64_C(0x004b80ffff80007f));
      arg2 = vcombine_s16(vcreate_s16(UINT64_C(0x7fff00008000aebc)),
                          vcreate_s16(UINT64_C(0x80007fff18f37fff)));
      clear_neon_saturated();
      //  Expect: "result" = 00ffffffff000000004b80ffff80007f
      result = vqshrun_high_n_s16(arg1, arg2, 3);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 0);
         exp = UINT64_C(0x004b80ffff80007f);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 1);
         exp = UINT64_C(0x00ffffffff000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1067() {

{
   {
      uint16x4_t arg1;
      int32x4_t arg2;
      uint16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"qshr\", fnname = \"vqshrun_high_n_s32\", rettype = \"uint16x8_t\", argtypes = \"[uint16x4_t,int32x4_t,__constrange(1,16) int]\", vals = [VectorVal [IntegerVal 65535,IntegerVal 56194,IntegerVal 48497,IntegerVal 32768],VectorVal [IntegerVal (-2147472337),IntegerVal (-32769),IntegerVal (-1089011713),IntegerVal 2147450879],IndexVal 12], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_u16(UINT64_C(0x8000bd71db82ffff));
      arg2 = vcombine_s32(vcreate_s32(UINT64_C(0xffff7fff80002c2f)),
                          vcreate_s32(UINT64_C(0x7fff7fffbf16ffff)));
      clear_neon_saturated();
      //  Expect: "result" = ffff0000000000008000bd71db82ffff
      result = vqshrun_high_n_s32(arg1, arg2, 12);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 0);
         exp = UINT64_C(0x8000bd71db82ffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 1);
         exp = UINT64_C(0xffff000000000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1068() {

{
   {
      uint32x2_t arg1;
      int64x2_t arg2;
      uint32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"qshr\", fnname = \"vqshrun_high_n_s64\", rettype = \"uint32x4_t\", argtypes = \"[uint32x2_t,int64x2_t,__constrange(1,32) int]\", vals = [VectorVal [IntegerVal 3634364416,IntegerVal 2147516416],VectorVal [IntegerVal 281472829194239,IntegerVal (-9223248099131031553)],IndexVal 2], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_u32(UINT64_C(0x80008000d8a00000));
      arg2 = vcombine_s64(vcreate_s64(UINT64_C(0x0000ffff7fff7fff)),
                          vcreate_s64(UINT64_C(0x800070b87fff7fff)));
      clear_neon_saturated();
      //  Expect: "result" = 00000000ffffffff80008000d8a00000
      result = vqshrun_high_n_s64(arg1, arg2, 2);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 0);
         exp = UINT64_C(0x80008000d8a00000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 1);
         exp = UINT64_C(0x00000000ffffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1069() {

{
   {
      int16x8_t arg1;
      uint8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"qrshr\", fnname = \"vqrshrun_n_s16\", rettype = \"uint8x8_t\", argtypes = \"[int16x8_t,__constrange(1,8) int]\", vals = [VectorVal [IntegerVal (-1),IntegerVal 32767,IntegerVal (-1),IntegerVal 32767,IntegerVal (-32768),IntegerVal 32767,IntegerVal 0,IntegerVal 32767],IndexVal 8], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcombine_s16(vcreate_s16(UINT64_C(0x7fffffff7fffffff)),
                          vcreate_s16(UINT64_C(0x7fff00007fff8000)));
      clear_neon_saturated();
      //  Expect: "result" = 8000800080008000
      result = vqrshrun_n_s16(arg1, 8);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u8(result), 0);
      exp = UINT64_C(0x8000800080008000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1070() {

{
   {
      int32x4_t arg1;
      uint16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"qrshr\", fnname = \"vqrshrun_n_s32\", rettype = \"uint16x4_t\", argtypes = \"[int32x4_t,__constrange(1,16) int]\", vals = [VectorVal [IntegerVal (-2147483648),IntegerVal (-32769),IntegerVal (-1505002220),IntegerVal (-2147418113)],IndexVal 5], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcombine_s32(vcreate_s32(UINT64_C(0xffff7fff80000000)),
                          vcreate_s32(UINT64_C(0x8000ffffa64b7d14)));
      clear_neon_saturated();
      //  Expect: "result" = 0000000000000000
      result = vqrshrun_n_s32(arg1, 5);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u16(result), 0);
      exp = 0;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1071() {

{
   {
      int64x2_t arg1;
      uint32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"qrshr\", fnname = \"vqrshrun_n_s64\", rettype = \"uint32x2_t\", argtypes = \"[int64x2_t,__constrange(1,32) int]\", vals = [VectorVal [IntegerVal 9223372034707292159,IntegerVal 140733193420799],IndexVal 21], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcombine_s64(vcreate_s64(UINT64_C(0x7fffffff7fffffff)),
                          vcreate_s64(UINT64_C(0x00007fff00007fff)));
      clear_neon_saturated();
      //  Expect: "result" = 03fff800ffffffff
      result = vqrshrun_n_s64(arg1, 21);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u32(result), 0);
      exp = UINT64_C(0x03fff800ffffffff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1072() {

{
   {
      int16_t arg1;
      uint8_t result;
      char* str1 = "ReproInfo2 {semantics = \"qrshr\", fnname = \"vqrshrunh_n_s16\", rettype = \"uint8_t\", argtypes = \"[int16_t,__constrange(1,8) int]\", vals = [IntegerVal 32767,IndexVal 2], start_saturated = False}";
      int reported = 0;
      uint8_t got;
      uint8_t exp;
      arg1 = 32767;
      clear_neon_saturated();
      //  Expect: "result" = ff
      result = vqrshrunh_n_s16(arg1, 2);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      got = result;
      exp = 255U;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1073() {

{
   {
      int32_t arg1;
      uint16_t result;
      char* str1 = "ReproInfo2 {semantics = \"qrshr\", fnname = \"vqrshruns_n_s32\", rettype = \"uint16_t\", argtypes = \"[int32_t,__constrange(1,16) int]\", vals = [IntegerVal 18580,IndexVal 4], start_saturated = False}";
      int reported = 0;
      uint16_t got;
      uint16_t exp;
      arg1 = 18580;
      clear_neon_saturated();
      //  Expect: "result" = 0489
      result = vqrshruns_n_s32(arg1, 4);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = 1161U;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1074() {

{
   {
      int64_t arg1;
      uint32_t result;
      char* str1 = "ReproInfo2 {semantics = \"qrshr\", fnname = \"vqrshrund_n_s64\", rettype = \"uint32_t\", argtypes = \"[int64_t,__constrange(1,32) int]\", vals = [IntegerVal 2948731858168348672,IndexVal 16], start_saturated = False}";
      int reported = 0;
      uint32_t got;
      uint32_t exp;
      arg1 = INT64_C(2948731858168348672);
      clear_neon_saturated();
      //  Expect: "result" = ffffffff
      result = vqrshrund_n_s64(arg1, 16);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      got = result;
      exp = 4294967295U;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIu32 " Got: %" PRIu32 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1075() {

{
   {
      uint8x8_t arg1;
      int16x8_t arg2;
      uint8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"qrshr\", fnname = \"vqrshrun_high_n_s16\", rettype = \"uint8x16_t\", argtypes = \"[uint8x8_t,int16x8_t,__constrange(1,8) int]\", vals = [VectorVal [IntegerVal 0,IntegerVal 128,IntegerVal 128,IntegerVal 255,IntegerVal 128,IntegerVal 0,IntegerVal 255,IntegerVal 255],VectorVal [IntegerVal (-1),IntegerVal 32767,IntegerVal 0,IntegerVal 32767,IntegerVal (-2785),IntegerVal (-32768),IntegerVal 32767,IntegerVal 18415],IndexVal 2], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_u8(UINT64_C(0xffff0080ff808000));
      arg2 = vcombine_s16(vcreate_s16(UINT64_C(0x7fff00007fffffff)),
                          vcreate_s16(UINT64_C(0x47ef7fff8000f51f)));
      clear_neon_saturated();
      //  Expect: "result" = ffff0000ff00ff00ffff0080ff808000
      result = vqrshrun_high_n_s16(arg1, arg2, 2);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 0);
         exp = UINT64_C(0xffff0080ff808000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 1);
         exp = UINT64_C(0xffff0000ff00ff00);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1076() {

{
   {
      uint16x4_t arg1;
      int32x4_t arg2;
      uint16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"qrshr\", fnname = \"vqrshrun_high_n_s32\", rettype = \"uint16x8_t\", argtypes = \"[uint16x4_t,int32x4_t,__constrange(1,16) int]\", vals = [VectorVal [IntegerVal 0,IntegerVal 32767,IntegerVal 32768,IntegerVal 32768],VectorVal [IntegerVal 2147450880,IntegerVal 392888320,IntegerVal 2147473241,IntegerVal (-50259)],IndexVal 3], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_u16(UINT64_C(0x800080007fff0000));
      arg2 = vcombine_s32(vcreate_s32(UINT64_C(0x176b00007fff8000)),
                          vcreate_s32(UINT64_C(0xffff3bad7fffd759)));
      clear_neon_saturated();
      //  Expect: "result" = 0000ffffffffffff800080007fff0000
      result = vqrshrun_high_n_s32(arg1, arg2, 3);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 0);
         exp = UINT64_C(0x800080007fff0000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 1);
         exp = UINT64_C(0x0000ffffffffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1077() {

{
   {
      uint32x2_t arg1;
      int64x2_t arg2;
      uint32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"qrshr\", fnname = \"vqrshrun_high_n_s64\", rettype = \"uint32x4_t\", argtypes = \"[uint32x2_t,int64x2_t,__constrange(1,32) int]\", vals = [VectorVal [IntegerVal 41538,IntegerVal 0],VectorVal [IntegerVal (-9223350422431891457),IntegerVal 9223369992450310143],IndexVal 21], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_u32(UINT64_C(0x000000000000a242));
      arg2 = vcombine_s64(vcreate_s64(UINT64_C(0x800013a87fff7fff)),
                          vcreate_s64(UINT64_C(0x7ffffe23ffff7fff)));
      clear_neon_saturated();
      //  Expect: "result" = ffffffff00000000000000000000a242
      result = vqrshrun_high_n_s64(arg1, arg2, 21);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 0);
         exp = UINT64_C(0x000000000000a242);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 1);
         exp = UINT64_C(0xffffffff00000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1078() {

{
   {
      int16x8_t arg1;
      int8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"qshr\", fnname = \"vqshrn_n_s16\", rettype = \"int8x8_t\", argtypes = \"[int16x8_t,__constrange(1,8) int]\", vals = [VectorVal [IntegerVal 0,IntegerVal 32767,IntegerVal 0,IntegerVal (-32768),IntegerVal 32767,IntegerVal 0,IntegerVal 0,IntegerVal (-32768)],IndexVal 4], start_saturated = True}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcombine_s16(vcreate_s16(UINT64_C(0x800000007fff0000)),
                          vcreate_s16(UINT64_C(0x8000000000007fff)));
      set_neon_saturated();
      //  Expect: "result" = 8000007f80007f00
      result = vqshrn_n_s16(arg1, 4);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s8(result), 0);
      exp = UINT64_C(0x8000007f80007f00);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1079() {

{
   {
      int32x4_t arg1;
      int16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"qshr\", fnname = \"vqshrn_n_s32\", rettype = \"int16x4_t\", argtypes = \"[int32x4_t,__constrange(1,16) int]\", vals = [VectorVal [IntegerVal (-777846785),IntegerVal 2147450879,IntegerVal (-2147450881),IntegerVal 32768],IndexVal 8], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcombine_s32(vcreate_s32(UINT64_C(0x7fff7fffd1a2ffff)),
                          vcreate_s32(UINT64_C(0x0000800080007fff)));
      clear_neon_saturated();
      //  Expect: "result" = 008080007fff8000
      result = vqshrn_n_s32(arg1, 8);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s16(result), 0);
      exp = UINT64_C(0x008080007fff8000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1080() {

{
   {
      int64x2_t arg1;
      int32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"qshr\", fnname = \"vqshrn_n_s64\", rettype = \"int32x2_t\", argtypes = \"[int64x2_t,__constrange(1,32) int]\", vals = [VectorVal [IntegerVal 179240991843123199,IntegerVal (-23845658427392)],IndexVal 13], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcombine_s64(vcreate_s64(UINT64_C(0x027ccabb7fff7fff)),
                          vcreate_s64(UINT64_C(0xffffea5000000000)));
      clear_neon_saturated();
      //  Expect: "result" = 800000007fffffff
      result = vqshrn_n_s64(arg1, 13);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s32(result), 0);
      exp = UINT64_C(0x800000007fffffff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1081() {

{
   {
      uint16x8_t arg1;
      uint8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"qshr\", fnname = \"vqshrn_n_u16\", rettype = \"uint8x8_t\", argtypes = \"[uint16x8_t,__constrange(1,8) int]\", vals = [VectorVal [IntegerVal 45412,IntegerVal 32767,IntegerVal 10935,IntegerVal 33034,IntegerVal 65535,IntegerVal 32768,IntegerVal 32767,IntegerVal 32768],IndexVal 3], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcombine_u16(vcreate_u16(UINT64_C(0x810a2ab77fffb164)),
                          vcreate_u16(UINT64_C(0x80007fff8000ffff)));
      clear_neon_saturated();
      //  Expect: "result" = ffffffffffffffff
      result = vqshrn_n_u16(arg1, 3);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u8(result), 0);
      exp = UINT64_C(0xffffffffffffffff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1082() {

{
   {
      uint32x4_t arg1;
      uint16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"qshr\", fnname = \"vqshrn_n_u32\", rettype = \"uint16x4_t\", argtypes = \"[uint32x4_t,__constrange(1,16) int]\", vals = [VectorVal [IntegerVal 4294901760,IntegerVal 2147483647,IntegerVal 2147516415,IntegerVal 2147483647],IndexVal 15], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcombine_u32(vcreate_u32(UINT64_C(0x7fffffffffff0000)),
                          vcreate_u32(UINT64_C(0x7fffffff80007fff)));
      clear_neon_saturated();
      //  Expect: "result" = ffffffffffffffff
      result = vqshrn_n_u32(arg1, 15);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u16(result), 0);
      exp = UINT64_C(0xffffffffffffffff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1083() {

{
   {
      uint64x2_t arg1;
      uint32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"qshr\", fnname = \"vqshrn_n_u64\", rettype = \"uint32x2_t\", argtypes = \"[uint64x2_t,__constrange(1,32) int]\", vals = [VectorVal [IntegerVal 9223260898133606399,IntegerVal 18446462598732869550],IndexVal 10], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcombine_u64(vcreate_u64(UINT64_C(0x7fff9aeb8000ffff)),
                          vcreate_u64(UINT64_C(0xffff000000006fae)));
      clear_neon_saturated();
      //  Expect: "result" = ffffffffffffffff
      result = vqshrn_n_u64(arg1, 10);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u32(result), 0);
      exp = UINT64_C(0xffffffffffffffff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1084() {

{
   {
      int16_t arg1;
      int8_t result;
      char* str1 = "ReproInfo2 {semantics = \"qshr\", fnname = \"vqshrnh_n_s16\", rettype = \"int8_t\", argtypes = \"[int16_t,__constrange(1,8) int]\", vals = [IntegerVal 32767,IndexVal 8], start_saturated = False}";
      int reported = 0;
      int8_t got;
      int8_t exp;
      arg1 = 32767;
      clear_neon_saturated();
      //  Expect: "result" = 7f
      result = vqshrnh_n_s16(arg1, 8);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = 127;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1085() {

{
   {
      int32_t arg1;
      int16_t result;
      char* str1 = "ReproInfo2 {semantics = \"qshr\", fnname = \"vqshrns_n_s32\", rettype = \"int16_t\", argtypes = \"[int32_t,__constrange(1,16) int]\", vals = [IntegerVal 1551925248,IndexVal 13], start_saturated = False}";
      int reported = 0;
      int16_t got;
      int16_t exp;
      arg1 = 1551925248;
      clear_neon_saturated();
      //  Expect: "result" = 7fff
      result = vqshrns_n_s32(arg1, 13);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      got = result;
      exp = 32767;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIi16 " Got: %" PRIi16 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1086() {

{
   {
      int64_t arg1;
      int32_t result;
      char* str1 = "ReproInfo2 {semantics = \"qshr\", fnname = \"vqshrnd_n_s64\", rettype = \"int32_t\", argtypes = \"[int64_t,__constrange(1,32) int]\", vals = [IntegerVal (-140735340904449),IndexVal 21], start_saturated = True}";
      int reported = 0;
      int32_t got;
      int32_t exp;
      arg1 = INT64_C(-140735340904449);
      set_neon_saturated();
      //  Expect: "result" = fc0003ff
      result = vqshrnd_n_s64(arg1, 21);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      got = result;
      exp = -67107841;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIi32 " Got: %" PRIi32 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1087() {

{
   {
      uint16_t arg1;
      uint8_t result;
      char* str1 = "ReproInfo2 {semantics = \"qshr\", fnname = \"vqshrnh_n_u16\", rettype = \"uint8_t\", argtypes = \"[uint16_t,__constrange(1,8) int]\", vals = [IntegerVal 0,IndexVal 3], start_saturated = False}";
      int reported = 0;
      uint8_t got;
      uint8_t exp;
      arg1 = 0;
      clear_neon_saturated();
      //  Expect: "result" = 00
      result = vqshrnh_n_u16(arg1, 3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = 0;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1088() {

{
   {
      uint32_t arg1;
      uint16_t result;
      char* str1 = "ReproInfo2 {semantics = \"qshr\", fnname = \"vqshrns_n_u32\", rettype = \"uint16_t\", argtypes = \"[uint32_t,__constrange(1,16) int]\", vals = [IntegerVal 0,IndexVal 11], start_saturated = False}";
      int reported = 0;
      uint16_t got;
      uint16_t exp;
      arg1 = 0;
      clear_neon_saturated();
      //  Expect: "result" = 0000
      result = vqshrns_n_u32(arg1, 11);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = 0;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1089() {

{
   {
      uint64_t arg1;
      uint32_t result;
      char* str1 = "ReproInfo2 {semantics = \"qshr\", fnname = \"vqshrnd_n_u64\", rettype = \"uint32_t\", argtypes = \"[uint64_t,__constrange(1,32) int]\", vals = [IntegerVal 15943727839015096400,IndexVal 32], start_saturated = False}";
      int reported = 0;
      uint32_t got;
      uint32_t exp;
      arg1 = UINT64_C(0xdd437fff00005050);
      clear_neon_saturated();
      //  Expect: "result" = dd437fff
      result = vqshrnd_n_u64(arg1, 32);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = 3712188415U;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIu32 " Got: %" PRIu32 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1090() {

{
   {
      int8x8_t arg1;
      int16x8_t arg2;
      int8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"qshr\", fnname = \"vqshrn_high_n_s16\", rettype = \"int8x16_t\", argtypes = \"[int8x8_t,int16x8_t,__constrange(1,8) int]\", vals = [VectorVal [IntegerVal 127,IntegerVal 127,IntegerVal (-39),IntegerVal 0,IntegerVal 127,IntegerVal (-128),IntegerVal (-128),IntegerVal (-128)],VectorVal [IntegerVal (-25242),IntegerVal (-32768),IntegerVal 1554,IntegerVal 12339,IntegerVal 32767,IntegerVal (-1),IntegerVal 27454,IntegerVal 32767],IndexVal 8], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_s8(UINT64_C(0x8080807f00d97f7f));
      arg2 = vcombine_s16(vcreate_s16(UINT64_C(0x3033061280009d66)),
                          vcreate_s16(UINT64_C(0x7fff6b3effff7fff)));
      clear_neon_saturated();
      //  Expect: "result" = 7f6bff7f3006809d8080807f00d97f7f
      result = vqshrn_high_n_s16(arg1, arg2, 8);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result), 0);
         exp = UINT64_C(0x8080807f00d97f7f);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result), 1);
         exp = UINT64_C(0x7f6bff7f3006809d);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1091() {

{
   {
      int16x4_t arg1;
      int32x4_t arg2;
      int16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"qshr\", fnname = \"vqshrn_high_n_s32\", rettype = \"int16x8_t\", argtypes = \"[int16x4_t,int32x4_t,__constrange(1,16) int]\", vals = [VectorVal [IntegerVal 0,IntegerVal 0,IntegerVal 32767,IntegerVal (-32768)],VectorVal [IntegerVal 32768,IntegerVal (-2147483648),IntegerVal 1443430400,IntegerVal 352681984],IndexVal 8], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_s16(UINT64_C(0x80007fff00000000));
      arg2 = vcombine_s32(vcreate_s32(UINT64_C(0x8000000000008000)),
                          vcreate_s32(UINT64_C(0x1505800056090000)));
      clear_neon_saturated();
      //  Expect: "result" = 7fff7fff8000008080007fff00000000
      result = vqshrn_high_n_s32(arg1, arg2, 8);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 0);
         exp = UINT64_C(0x80007fff00000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 1);
         exp = UINT64_C(0x7fff7fff80000080);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1092() {

{
   {
      int32x2_t arg1;
      int64x2_t arg2;
      int32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"qshr\", fnname = \"vqshrn_high_n_s64\", rettype = \"int32x4_t\", argtypes = \"[int32x2_t,int64x2_t,__constrange(1,32) int]\", vals = [VectorVal [IntegerVal (-32768),IntegerVal (-2147450880)],VectorVal [IntegerVal 9223166612863975423,IntegerVal 186592706658304],IndexVal 26], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_s32(UINT64_C(0x80008000ffff8000));
      arg2 = vcombine_s64(vcreate_s64(UINT64_C(0x7fff452affffffff)),
                          vcreate_s64(UINT64_C(0x0000a9b47fff8000)));
      clear_neon_saturated();
      //  Expect: "result" = 002a6d1f7fffffff80008000ffff8000
      result = vqshrn_high_n_s64(arg1, arg2, 26);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 0);
         exp = UINT64_C(0x80008000ffff8000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 1);
         exp = UINT64_C(0x002a6d1f7fffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1093() {

{
   {
      uint8x8_t arg1;
      uint16x8_t arg2;
      uint8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"qshr\", fnname = \"vqshrn_high_n_u16\", rettype = \"uint8x16_t\", argtypes = \"[uint8x8_t,uint16x8_t,__constrange(1,8) int]\", vals = [VectorVal [IntegerVal 154,IntegerVal 255,IntegerVal 0,IntegerVal 0,IntegerVal 128,IntegerVal 127,IntegerVal 255,IntegerVal 122],VectorVal [IntegerVal 32767,IntegerVal 0,IntegerVal 65535,IntegerVal 32767,IntegerVal 32768,IntegerVal 65535,IntegerVal 65535,IntegerVal 32768],IndexVal 5], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_u8(UINT64_C(0x7aff7f800000ff9a));
      arg2 = vcombine_u16(vcreate_u16(UINT64_C(0x7fffffff00007fff)),
                          vcreate_u16(UINT64_C(0x8000ffffffff8000)));
      clear_neon_saturated();
      //  Expect: "result" = ffffffffffff00ff7aff7f800000ff9a
      result = vqshrn_high_n_u16(arg1, arg2, 5);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 0);
         exp = UINT64_C(0x7aff7f800000ff9a);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 1);
         exp = UINT64_C(0xffffffffffff00ff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1094() {

{
   {
      uint16x4_t arg1;
      uint32x4_t arg2;
      uint16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"qshr\", fnname = \"vqshrn_high_n_u32\", rettype = \"uint16x8_t\", argtypes = \"[uint16x4_t,uint32x4_t,__constrange(1,16) int]\", vals = [VectorVal [IntegerVal 0,IntegerVal 0,IntegerVal 0,IntegerVal 32767],VectorVal [IntegerVal 2268069888,IntegerVal 32768,IntegerVal 2147483647,IntegerVal 2147450880],IndexVal 1], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_u16(UINT64_C(0x7fff000000000000));
      arg2 = vcombine_u32(vcreate_u32(UINT64_C(0x0000800087300000)),
                          vcreate_u32(UINT64_C(0x7fff80007fffffff)));
      clear_neon_saturated();
      //  Expect: "result" = ffffffff4000ffff7fff000000000000
      result = vqshrn_high_n_u32(arg1, arg2, 1);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 0);
         exp = UINT64_C(0x7fff000000000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 1);
         exp = UINT64_C(0xffffffff4000ffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1095() {

{
   {
      uint32x2_t arg1;
      uint64x2_t arg2;
      uint32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"qshr\", fnname = \"vqshrn_high_n_u64\", rettype = \"uint32x4_t\", argtypes = \"[uint32x2_t,uint64x2_t,__constrange(1,32) int]\", vals = [VectorVal [IntegerVal 65535,IntegerVal 4294934527],VectorVal [IntegerVal 18446603334073679871,IntegerVal 140737488363505],IndexVal 26], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_u32(UINT64_C(0xffff7fff0000ffff));
      arg2 = vcombine_u64(vcreate_u64(UINT64_C(0xffff7fff7fff7fff)),
                          vcreate_u64(UINT64_C(0x0000800000001ff1)));
      clear_neon_saturated();
      //  Expect: "result" = 00200000ffffffffffff7fff0000ffff
      result = vqshrn_high_n_u64(arg1, arg2, 26);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 0);
         exp = UINT64_C(0xffff7fff0000ffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 1);
         exp = UINT64_C(0x00200000ffffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1096() {

{
   {
      int16x8_t arg1;
      int8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"rshr\", fnname = \"vrshrn_n_s16\", rettype = \"int8x8_t\", argtypes = \"[int16x8_t,__constrange(1,8) int]\", vals = [VectorVal [IntegerVal 32767,IntegerVal 32767,IntegerVal 0,IntegerVal 7074,IntegerVal (-32768),IntegerVal (-32768),IntegerVal (-1),IntegerVal (-32768)],IndexVal 7], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcombine_s16(vcreate_s16(UINT64_C(0x1ba200007fff7fff)),
                          vcreate_s16(UINT64_C(0x8000ffff80008000)));
      clear_neon_saturated();
      //  Expect: "result" = 0000000037000000
      result = vrshrn_n_s16(arg1, 7);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s8(result), 0);
      exp = UINT64_C(0x0000000037000000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1097() {

{
   {
      int32x4_t arg1;
      int16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"rshr\", fnname = \"vrshrn_n_s32\", rettype = \"int16x4_t\", argtypes = \"[int32x4_t,__constrange(1,16) int]\", vals = [VectorVal [IntegerVal 32767,IntegerVal (-25852),IntegerVal (-2147418113),IntegerVal 32768],IndexVal 8], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcombine_s32(vcreate_s32(UINT64_C(0xffff9b0400007fff)),
                          vcreate_s32(UINT64_C(0x000080008000ffff)));
      clear_neon_saturated();
      //  Expect: "result" = 00800100ff9b0080
      result = vrshrn_n_s32(arg1, 8);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s16(result), 0);
      exp = UINT64_C(0x00800100ff9b0080);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1098() {

{
   {
      int64x2_t arg1;
      int32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"rshr\", fnname = \"vrshrn_n_s64\", rettype = \"int32x2_t\", argtypes = \"[int64x2_t,__constrange(1,32) int]\", vals = [VectorVal [IntegerVal 132536248238080,IntegerVal 9223372034332098559],IndexVal 23], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcombine_s64(vcreate_s64(UINT64_C(0x0000788a7fff0000)),
                          vcreate_s64(UINT64_C(0x7fffffff69a2ffff)));
      clear_neon_saturated();
      //  Expect: "result" = fffffed300f11500
      result = vrshrn_n_s64(arg1, 23);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s32(result), 0);
      exp = UINT64_C(0xfffffed300f11500);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1099() {

{
   {
      uint16x8_t arg1;
      uint8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"rshr\", fnname = \"vrshrn_n_u16\", rettype = \"uint8x8_t\", argtypes = \"[uint16x8_t,__constrange(1,8) int]\", vals = [VectorVal [IntegerVal 0,IntegerVal 39225,IntegerVal 65535,IntegerVal 0,IntegerVal 29212,IntegerVal 29260,IntegerVal 0,IntegerVal 65535],IndexVal 2], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcombine_u16(vcreate_u16(UINT64_C(0x0000ffff99390000)),
                          vcreate_u16(UINT64_C(0xffff0000724c721c)));
      clear_neon_saturated();
      //  Expect: "result" = 0000938700004e00
      result = vrshrn_n_u16(arg1, 2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u8(result), 0);
      exp = UINT64_C(0x0000938700004e00);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1100() {

{
   {
      uint32x4_t arg1;
      uint16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"rshr\", fnname = \"vrshrn_n_u32\", rettype = \"uint16x4_t\", argtypes = \"[uint32x4_t,__constrange(1,16) int]\", vals = [VectorVal [IntegerVal 2147483648,IntegerVal 65535,IntegerVal 2147483648,IntegerVal 20149],IndexVal 10], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcombine_u32(vcreate_u32(UINT64_C(0x0000ffff80000000)),
                          vcreate_u32(UINT64_C(0x00004eb580000000)));
      clear_neon_saturated();
      //  Expect: "result" = 0014000000400000
      result = vrshrn_n_u32(arg1, 10);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u16(result), 0);
      exp = UINT64_C(0x0014000000400000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1101() {

{
   {
      uint64x2_t arg1;
      uint32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"rshr\", fnname = \"vrshrn_n_u64\", rettype = \"uint32x2_t\", argtypes = \"[uint64x2_t,__constrange(1,32) int]\", vals = [VectorVal [IntegerVal 18446603331926294527,IntegerVal 9223231301513847006],IndexVal 20], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcombine_u64(vcreate_u64(UINT64_C(0xffff7fff0000ffff)),
                          vcreate_u64(UINT64_C(0x7fff80007fff20de)));
      clear_neon_saturated();
      //  Expect: "result" = f8000800f7fff000
      result = vrshrn_n_u64(arg1, 20);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u32(result), 0);
      exp = UINT64_C(0xf8000800f7fff000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1102() {

{
   {
      int8x8_t arg1;
      int16x8_t arg2;
      int8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"rshr\", fnname = \"vrshrn_high_n_s16\", rettype = \"int8x16_t\", argtypes = \"[int8x8_t,int16x8_t,__constrange(1,8) int]\", vals = [VectorVal [IntegerVal 127,IntegerVal 127,IntegerVal 0,IntegerVal 127,IntegerVal 127,IntegerVal (-1),IntegerVal (-116),IntegerVal (-1)],VectorVal [IntegerVal 0,IntegerVal (-1),IntegerVal 27400,IntegerVal (-32768),IntegerVal 32767,IntegerVal (-32768),IntegerVal (-1),IntegerVal (-32768)],IndexVal 8], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_s8(UINT64_C(0xff8cff7f7f007f7f));
      arg2 = vcombine_s16(vcreate_s16(UINT64_C(0x80006b08ffff0000)),
                          vcreate_s16(UINT64_C(0x8000ffff80007fff)));
      clear_neon_saturated();
      //  Expect: "result" = 80008080806b0000ff8cff7f7f007f7f
      result = vrshrn_high_n_s16(arg1, arg2, 8);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result), 0);
         exp = UINT64_C(0xff8cff7f7f007f7f);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result), 1);
         exp = UINT64_C(0x80008080806b0000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1103() {

{
   {
      int16x4_t arg1;
      int32x4_t arg2;
      int16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"rshr\", fnname = \"vrshrn_high_n_s32\", rettype = \"int16x8_t\", argtypes = \"[int16x4_t,int32x4_t,__constrange(1,16) int]\", vals = [VectorVal [IntegerVal 32767,IntegerVal (-6024),IntegerVal (-1),IntegerVal 0],VectorVal [IntegerVal (-2147448964),IntegerVal (-1),IntegerVal (-2147437308),IntegerVal 2147483647],IndexVal 9], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_s16(UINT64_C(0x0000ffffe8787fff));
      arg2 = vcombine_s32(vcreate_s32(UINT64_C(0xffffffff8000877c)),
                          vcreate_s32(UINT64_C(0x7fffffff8000b504)));
      clear_neon_saturated();
      //  Expect: "result" = 0000005b000000440000ffffe8787fff
      result = vrshrn_high_n_s32(arg1, arg2, 9);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 0);
         exp = UINT64_C(0x0000ffffe8787fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 1);
         exp = UINT64_C(0x0000005b00000044);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1104() {

{
   {
      int32x2_t arg1;
      int64x2_t arg2;
      int32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"rshr\", fnname = \"vrshrn_high_n_s64\", rettype = \"int32x4_t\", argtypes = \"[int32x2_t,int64x2_t,__constrange(1,32) int]\", vals = [VectorVal [IntegerVal (-2147450881),IntegerVal (-2147450880)],VectorVal [IntegerVal 4294919455,IntegerVal 1393160399376875520],IndexVal 3], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_s32(UINT64_C(0x8000800080007fff));
      arg2 = vcombine_s64(vcreate_s64(UINT64_C(0x00000000ffff451f)),
                          vcreate_s64(UINT64_C(0x1355800080000000)));
      clear_neon_saturated();
      //  Expect: "result" = 100000001fffe8a48000800080007fff
      result = vrshrn_high_n_s64(arg1, arg2, 3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 0);
         exp = UINT64_C(0x8000800080007fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 1);
         exp = UINT64_C(0x100000001fffe8a4);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1105() {

{
   {
      uint8x8_t arg1;
      uint16x8_t arg2;
      uint8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"rshr\", fnname = \"vrshrn_high_n_u16\", rettype = \"uint8x16_t\", argtypes = \"[uint8x8_t,uint16x8_t,__constrange(1,8) int]\", vals = [VectorVal [IntegerVal 255,IntegerVal 109,IntegerVal 127,IntegerVal 206,IntegerVal 255,IntegerVal 127,IntegerVal 127,IntegerVal 0],VectorVal [IntegerVal 39473,IntegerVal 32767,IntegerVal 65535,IntegerVal 0,IntegerVal 0,IntegerVal 51121,IntegerVal 63592,IntegerVal 32768],IndexVal 2], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_u8(UINT64_C(0x007f7fffce7f6dff));
      arg2 = vcombine_u16(vcreate_u16(UINT64_C(0x0000ffff7fff9a31)),
                          vcreate_u16(UINT64_C(0x8000f868c7b10000)));
      clear_neon_saturated();
      //  Expect: "result" = 001aec000000008c007f7fffce7f6dff
      result = vrshrn_high_n_u16(arg1, arg2, 2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 0);
         exp = UINT64_C(0x007f7fffce7f6dff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 1);
         exp = UINT64_C(0x001aec000000008c);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1106() {

{
   {
      uint16x4_t arg1;
      uint32x4_t arg2;
      uint16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"rshr\", fnname = \"vrshrn_high_n_u32\", rettype = \"uint16x8_t\", argtypes = \"[uint16x4_t,uint32x4_t,__constrange(1,16) int]\", vals = [VectorVal [IntegerVal 32768,IntegerVal 32767,IntegerVal 61716,IntegerVal 65535],VectorVal [IntegerVal 65535,IntegerVal 4294901760,IntegerVal 1602095655,IntegerVal 2080800768],IndexVal 12], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_u16(UINT64_C(0xfffff1147fff8000));
      arg2 = vcombine_u32(vcreate_u32(UINT64_C(0xffff00000000ffff)),
                          vcreate_u32(UINT64_C(0x7c0680005f7e0a27)));
      clear_neon_saturated();
      //  Expect: "result" = c068f7e1fff00010fffff1147fff8000
      result = vrshrn_high_n_u32(arg1, arg2, 12);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 0);
         exp = UINT64_C(0xfffff1147fff8000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 1);
         exp = UINT64_C(0xc068f7e1fff00010);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1107() {

{
   {
      uint32x2_t arg1;
      uint64x2_t arg2;
      uint32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"rshr\", fnname = \"vrshrn_high_n_u64\", rettype = \"uint32x4_t\", argtypes = \"[uint32x2_t,uint64x2_t,__constrange(1,32) int]\", vals = [VectorVal [IntegerVal 4294934528,IntegerVal 4294901760],VectorVal [IntegerVal 18446603339282166634,IntegerVal 1039627822531477504],IndexVal 2], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_u32(UINT64_C(0xffff0000ffff8000));
      arg2 = vcombine_u64(vcreate_u64(UINT64_C(0xffff8000b672b36a)),
                          vcreate_u64(UINT64_C(0x0e6d7fff149a0000)));
      clear_neon_saturated();
      //  Expect: "result" = c52680002d9cacdbffff0000ffff8000
      result = vrshrn_high_n_u64(arg1, arg2, 2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 0);
         exp = UINT64_C(0xffff0000ffff8000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 1);
         exp = UINT64_C(0xc52680002d9cacdb);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1108() {

{
   {
      int16x8_t arg1;
      int8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"qrshr\", fnname = \"vqrshrn_n_s16\", rettype = \"int8x8_t\", argtypes = \"[int16x8_t,__constrange(1,8) int]\", vals = [VectorVal [IntegerVal 32767,IntegerVal (-1),IntegerVal 32767,IntegerVal (-32768),IntegerVal (-1),IntegerVal 32767,IntegerVal (-32768),IntegerVal (-1)],IndexVal 4], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcombine_s16(vcreate_s16(UINT64_C(0x80007fffffff7fff)),
                          vcreate_s16(UINT64_C(0xffff80007fffffff)));
      clear_neon_saturated();
      //  Expect: "result" = 00807f00807f007f
      result = vqrshrn_n_s16(arg1, 4);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s8(result), 0);
      exp = UINT64_C(0x00807f00807f007f);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1109() {

{
   {
      int32x4_t arg1;
      int16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"qrshr\", fnname = \"vqrshrn_n_s32\", rettype = \"int16x4_t\", argtypes = \"[int32x4_t,__constrange(1,16) int]\", vals = [VectorVal [IntegerVal (-1),IntegerVal (-2147483648),IntegerVal 2147418112,IntegerVal 501841919],IndexVal 11], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcombine_s32(vcreate_s32(UINT64_C(0x80000000ffffffff)),
                          vcreate_s32(UINT64_C(0x1de97fff7fff0000)));
      clear_neon_saturated();
      //  Expect: "result" = 7fff7fff80000000
      result = vqrshrn_n_s32(arg1, 11);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s16(result), 0);
      exp = UINT64_C(0x7fff7fff80000000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1110() {

{
   {
      int64x2_t arg1;
      int32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"qrshr\", fnname = \"vqrshrn_n_s64\", rettype = \"int32x2_t\", argtypes = \"[int64x2_t,__constrange(1,32) int]\", vals = [VectorVal [IntegerVal 824185581796899427,IntegerVal 140739635806952],IndexVal 12], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcombine_s64(vcreate_s64(UINT64_C(0x0b70186b8000ba63)),
                          vcreate_s64(UINT64_C(0x000080007fff82e8)));
      clear_neon_saturated();
      //  Expect: "result" = 7fffffff7fffffff
      result = vqrshrn_n_s64(arg1, 12);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s32(result), 0);
      exp = UINT64_C(0x7fffffff7fffffff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1111() {

{
   {
      uint16x8_t arg1;
      uint8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"qrshr\", fnname = \"vqrshrn_n_u16\", rettype = \"uint8x8_t\", argtypes = \"[uint16x8_t,__constrange(1,8) int]\", vals = [VectorVal [IntegerVal 32768,IntegerVal 32768,IntegerVal 65535,IntegerVal 65535,IntegerVal 32767,IntegerVal 26810,IntegerVal 65535,IntegerVal 65535],IndexVal 2], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcombine_u16(vcreate_u16(UINT64_C(0xffffffff80008000)),
                          vcreate_u16(UINT64_C(0xffffffff68ba7fff)));
      clear_neon_saturated();
      //  Expect: "result" = ffffffffffffffff
      result = vqrshrn_n_u16(arg1, 2);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u8(result), 0);
      exp = UINT64_C(0xffffffffffffffff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1112() {

{
   {
      uint32x4_t arg1;
      uint16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"qrshr\", fnname = \"vqrshrn_n_u32\", rettype = \"uint16x4_t\", argtypes = \"[uint32x4_t,__constrange(1,16) int]\", vals = [VectorVal [IntegerVal 65535,IntegerVal 4033249280,IntegerVal 32768,IntegerVal 62924],IndexVal 11], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcombine_u32(vcreate_u32(UINT64_C(0xf06680000000ffff)),
                          vcreate_u32(UINT64_C(0x0000f5cc00008000)));
      clear_neon_saturated();
      //  Expect: "result" = 001f0010ffff0020
      result = vqrshrn_n_u32(arg1, 11);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u16(result), 0);
      exp = UINT64_C(0x001f0010ffff0020);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1113() {

{
   {
      uint64x2_t arg1;
      uint32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"qrshr\", fnname = \"vqrshrn_n_u64\", rettype = \"uint32x2_t\", argtypes = \"[uint64x2_t,__constrange(1,32) int]\", vals = [VectorVal [IntegerVal 18446744073709486080,IntegerVal 9223372032559841280],IndexVal 24], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcombine_u64(vcreate_u64(UINT64_C(0xffffffffffff0000)),
                          vcreate_u64(UINT64_C(0x7fffffff00008000)));
      clear_neon_saturated();
      //  Expect: "result" = ffffffffffffffff
      result = vqrshrn_n_u64(arg1, 24);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u32(result), 0);
      exp = UINT64_C(0xffffffffffffffff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1114() {

{
   {
      int16_t arg1;
      int8_t result;
      char* str1 = "ReproInfo2 {semantics = \"qrshr\", fnname = \"vqrshrnh_n_s16\", rettype = \"int8_t\", argtypes = \"[int16_t,__constrange(1,8) int]\", vals = [IntegerVal 26970,IndexVal 8], start_saturated = False}";
      int reported = 0;
      int8_t got;
      int8_t exp;
      arg1 = 26970;
      clear_neon_saturated();
      //  Expect: "result" = 69
      result = vqrshrnh_n_s16(arg1, 8);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = 105;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1115() {

{
   {
      int32_t arg1;
      int16_t result;
      char* str1 = "ReproInfo2 {semantics = \"qrshr\", fnname = \"vqrshrns_n_s32\", rettype = \"int16_t\", argtypes = \"[int32_t,__constrange(1,16) int]\", vals = [IntegerVal 2147483647,IndexVal 8], start_saturated = False}";
      int reported = 0;
      int16_t got;
      int16_t exp;
      arg1 = 2147483647;
      clear_neon_saturated();
      //  Expect: "result" = 7fff
      result = vqrshrns_n_s32(arg1, 8);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      got = result;
      exp = 32767;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIi16 " Got: %" PRIi16 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1116() {

{
   {
      int64_t arg1;
      int32_t result;
      char* str1 = "ReproInfo2 {semantics = \"qrshr\", fnname = \"vqrshrnd_n_s64\", rettype = \"int32_t\", argtypes = \"[int64_t,__constrange(1,32) int]\", vals = [IntegerVal (-9223372036854710273),IndexVal 32], start_saturated = False}";
      int reported = 0;
      int32_t got;
      int32_t exp;
      arg1 = INT64_C(-9223372036854710273);
      clear_neon_saturated();
      //  Expect: "result" = 80000000
      result = vqrshrnd_n_s64(arg1, 32);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = (int32_t) 0x80000000;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIi32 " Got: %" PRIi32 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1117() {

{
   {
      uint16_t arg1;
      uint8_t result;
      char* str1 = "ReproInfo2 {semantics = \"qrshr\", fnname = \"vqrshrnh_n_u16\", rettype = \"uint8_t\", argtypes = \"[uint16_t,__constrange(1,8) int]\", vals = [IntegerVal 32767,IndexVal 1], start_saturated = False}";
      int reported = 0;
      uint8_t got;
      uint8_t exp;
      arg1 = 32767U;
      clear_neon_saturated();
      //  Expect: "result" = ff
      result = vqrshrnh_n_u16(arg1, 1);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      got = result;
      exp = 255U;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1118() {

{
   {
      uint32_t arg1;
      uint16_t result;
      char* str1 = "ReproInfo2 {semantics = \"qrshr\", fnname = \"vqrshrns_n_u32\", rettype = \"uint16_t\", argtypes = \"[uint32_t,__constrange(1,16) int]\", vals = [IntegerVal 2147549183,IndexVal 13], start_saturated = True}";
      int reported = 0;
      uint16_t got;
      uint16_t exp;
      arg1 = 2147549183U;
      set_neon_saturated();
      //  Expect: "result" = ffff
      result = vqrshrns_n_u32(arg1, 13);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      got = result;
      exp = 65535U;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1119() {

{
   {
      uint64_t arg1;
      uint32_t result;
      char* str1 = "ReproInfo2 {semantics = \"qrshr\", fnname = \"vqrshrnd_n_u64\", rettype = \"uint32_t\", argtypes = \"[uint64_t,__constrange(1,32) int]\", vals = [IntegerVal 9223653507536584703,IndexVal 21], start_saturated = False}";
      int reported = 0;
      uint32_t got;
      uint32_t exp;
      arg1 = UINT64_C(0x8000ffff0000ffff);
      clear_neon_saturated();
      //  Expect: "result" = ffffffff
      result = vqrshrnd_n_u64(arg1, 21);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      got = result;
      exp = 4294967295U;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIu32 " Got: %" PRIu32 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1120() {

{
   {
      int8x8_t arg1;
      int16x8_t arg2;
      int8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"qrshr\", fnname = \"vqrshrn_high_n_s16\", rettype = \"int8x16_t\", argtypes = \"[int8x8_t,int16x8_t,__constrange(1,8) int]\", vals = [VectorVal [IntegerVal (-10),IntegerVal 127,IntegerVal (-128),IntegerVal (-1),IntegerVal 0,IntegerVal (-78),IntegerVal (-1),IntegerVal (-128)],VectorVal [IntegerVal 32767,IntegerVal (-1),IntegerVal 32767,IntegerVal 32767,IntegerVal 0,IntegerVal (-28238),IntegerVal (-1),IntegerVal (-1)],IndexVal 1], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_s8(UINT64_C(0x80ffb200ff807ff6));
      arg2 = vcombine_s16(vcreate_s16(UINT64_C(0x7fff7fffffff7fff)),
                          vcreate_s16(UINT64_C(0xffffffff91b20000)));
      clear_neon_saturated();
      //  Expect: "result" = 000080007f7f007f80ffb200ff807ff6
      result = vqrshrn_high_n_s16(arg1, arg2, 1);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result), 0);
         exp = UINT64_C(0x80ffb200ff807ff6);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result), 1);
         exp = UINT64_C(0x000080007f7f007f);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1121() {

{
   {
      int16x4_t arg1;
      int32x4_t arg2;
      int16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"qrshr\", fnname = \"vqrshrn_high_n_s32\", rettype = \"int16x8_t\", argtypes = \"[int16x4_t,int32x4_t,__constrange(1,16) int]\", vals = [VectorVal [IntegerVal 9603,IntegerVal (-13911),IntegerVal 32767,IntegerVal 32767],VectorVal [IntegerVal (-2147483648),IntegerVal 12279,IntegerVal (-32769),IntegerVal (-2147418113)],IndexVal 3], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_s16(UINT64_C(0x7fff7fffc9a92583));
      arg2 = vcombine_s32(vcreate_s32(UINT64_C(0x00002ff780000000)),
                          vcreate_s32(UINT64_C(0x8000ffffffff7fff)));
      clear_neon_saturated();
      //  Expect: "result" = 8000f00005ff80007fff7fffc9a92583
      result = vqrshrn_high_n_s32(arg1, arg2, 3);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 0);
         exp = UINT64_C(0x7fff7fffc9a92583);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 1);
         exp = UINT64_C(0x8000f00005ff8000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1122() {

{
   {
      int32x2_t arg1;
      int64x2_t arg2;
      int32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"qrshr\", fnname = \"vqrshrn_high_n_s64\", rettype = \"int32x4_t\", argtypes = \"[int32x2_t,int64x2_t,__constrange(1,32) int]\", vals = [VectorVal [IntegerVal 2147418112,IntegerVal (-2147418113)],VectorVal [IntegerVal 7838092938973270847,IntegerVal (-9223372034707259392)],IndexVal 19], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_s32(UINT64_C(0x8000ffff7fff0000));
      arg2 = vcombine_s64(vcreate_s64(UINT64_C(0x6cc67fffffffd33f)),
                          vcreate_s64(UINT64_C(0x8000000080008000)));
      clear_neon_saturated();
      //  Expect: "result" = 800000007fffffff8000ffff7fff0000
      result = vqrshrn_high_n_s64(arg1, arg2, 19);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 0);
         exp = UINT64_C(0x8000ffff7fff0000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 1);
         exp = UINT64_C(0x800000007fffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1123() {

{
   {
      uint8x8_t arg1;
      uint16x8_t arg2;
      uint8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"qrshr\", fnname = \"vqrshrn_high_n_u16\", rettype = \"uint8x16_t\", argtypes = \"[uint8x8_t,uint16x8_t,__constrange(1,8) int]\", vals = [VectorVal [IntegerVal 128,IntegerVal 0,IntegerVal 137,IntegerVal 128,IntegerVal 255,IntegerVal 127,IntegerVal 128,IntegerVal 128],VectorVal [IntegerVal 0,IntegerVal 0,IntegerVal 32768,IntegerVal 32768,IntegerVal 9863,IntegerVal 32767,IntegerVal 32768,IntegerVal 32768],IndexVal 5], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_u8(UINT64_C(0x80807fff80890080));
      arg2 = vcombine_u16(vcreate_u16(UINT64_C(0x8000800000000000)),
                          vcreate_u16(UINT64_C(0x800080007fff2687)));
      clear_neon_saturated();
      //  Expect: "result" = ffffffffffff000080807fff80890080
      result = vqrshrn_high_n_u16(arg1, arg2, 5);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 0);
         exp = UINT64_C(0x80807fff80890080);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 1);
         exp = UINT64_C(0xffffffffffff0000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1124() {

{
   {
      uint16x4_t arg1;
      uint32x4_t arg2;
      uint16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"qrshr\", fnname = \"vqrshrn_high_n_u32\", rettype = \"uint16x8_t\", argtypes = \"[uint16x4_t,uint32x4_t,__constrange(1,16) int]\", vals = [VectorVal [IntegerVal 65535,IntegerVal 32767,IntegerVal 32767,IntegerVal 0],VectorVal [IntegerVal 2147501401,IntegerVal 4294915297,IntegerVal 2147483648,IntegerVal 2147474747],IndexVal 1], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_u16(UINT64_C(0x00007fff7fffffff));
      arg2 = vcombine_u32(vcreate_u32(UINT64_C(0xffff34e180004559)),
                          vcreate_u32(UINT64_C(0x7fffdd3b80000000)));
      clear_neon_saturated();
      //  Expect: "result" = ffffffffffffffff00007fff7fffffff
      result = vqrshrn_high_n_u32(arg1, arg2, 1);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 0);
         exp = UINT64_C(0x00007fff7fffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 1);
         exp = UINT64_C(0xffffffffffffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1125() {

{
   {
      uint32x2_t arg1;
      uint64x2_t arg2;
      uint32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"qrshr\", fnname = \"vqrshrn_high_n_u64\", rettype = \"uint32x4_t\", argtypes = \"[uint32x2_t,uint64x2_t,__constrange(1,32) int]\", vals = [VectorVal [IntegerVal 813334527,IntegerVal 2147418112],VectorVal [IntegerVal 140735340806144,IntegerVal 9223246595892445184],IndexVal 26], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_u32(UINT64_C(0x7fff0000307a7fff));
      arg2 = vcombine_u64(vcreate_u64(UINT64_C(0x00007fff7fff0000)),
                          vcreate_u64(UINT64_C(0x7fff8de980000000)));
      clear_neon_saturated();
      //  Expect: "result" = ffffffff001fffe07fff0000307a7fff
      result = vqrshrn_high_n_u64(arg1, arg2, 26);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 0);
         exp = UINT64_C(0x7fff0000307a7fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 1);
         exp = UINT64_C(0xffffffff001fffe0);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1126() {

{
   {
      int8x8_t arg1;
      int16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"shl\", fnname = \"vshll_n_s8\", rettype = \"int16x8_t\", argtypes = \"[int8x8_t,__constrange(1,8) int]\", vals = [VectorVal [IntegerVal (-10),IntegerVal 0,IntegerVal 127,IntegerVal 0,IntegerVal (-1),IntegerVal 127,IntegerVal 127,IntegerVal 0],IndexVal 1], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_s8(UINT64_C(0x007f7fff007f00f6));
      clear_neon_saturated();
      //  Expect: "result" = 000000fe00fefffe000000fe0000ffec
      result = vshll_n_s8(arg1, 1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 0);
         exp = UINT64_C(0x000000fe0000ffec);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 1);
         exp = UINT64_C(0x000000fe00fefffe);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1127() {

{
   {
      int16x4_t arg1;
      int32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"shl\", fnname = \"vshll_n_s16\", rettype = \"int32x4_t\", argtypes = \"[int16x4_t,__constrange(1,16) int]\", vals = [VectorVal [IntegerVal (-1),IntegerVal 32767,IntegerVal (-1),IntegerVal 32767],IndexVal 1], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_s16(UINT64_C(0x7fffffff7fffffff));
      clear_neon_saturated();
      //  Expect: "result" = 0000fffefffffffe0000fffefffffffe
      result = vshll_n_s16(arg1, 1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 0);
         exp = UINT64_C(0x0000fffefffffffe);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 1);
         exp = UINT64_C(0x0000fffefffffffe);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1128() {

{
   {
      int32x2_t arg1;
      int64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"shl\", fnname = \"vshll_n_s32\", rettype = \"int64x2_t\", argtypes = \"[int32x2_t,__constrange(1,32) int]\", vals = [VectorVal [IntegerVal 2121400320,IntegerVal (-2147483648)],IndexVal 11], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_s32(UINT64_C(0x800000007e720000));
      clear_neon_saturated();
      //  Expect: "result" = fffffc0000000000000003f390000000
      result = vshll_n_s32(arg1, 11);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 0);
         exp = UINT64_C(0x000003f390000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 1);
         exp = UINT64_C(0xfffffc0000000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1129() {

{
   {
      uint8x8_t arg1;
      uint16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"shl\", fnname = \"vshll_n_u8\", rettype = \"uint16x8_t\", argtypes = \"[uint8x8_t,__constrange(1,8) int]\", vals = [VectorVal [IntegerVal 168,IntegerVal 128,IntegerVal 128,IntegerVal 127,IntegerVal 127,IntegerVal 0,IntegerVal 128,IntegerVal 0],IndexVal 8], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_u8(UINT64_C(0x0080007f7f8080a8));
      clear_neon_saturated();
      //  Expect: "result" = 0000800000007f007f0080008000a800
      result = vshll_n_u8(arg1, 8);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 0);
         exp = UINT64_C(0x7f0080008000a800);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 1);
         exp = UINT64_C(0x0000800000007f00);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1130() {

{
   {
      uint16x4_t arg1;
      uint32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"shl\", fnname = \"vshll_n_u16\", rettype = \"uint32x4_t\", argtypes = \"[uint16x4_t,__constrange(1,16) int]\", vals = [VectorVal [IntegerVal 50334,IntegerVal 32768,IntegerVal 0,IntegerVal 57593],IndexVal 6], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_u16(UINT64_C(0xe0f900008000c49e));
      clear_neon_saturated();
      //  Expect: "result" = 00383e40000000000020000000312780
      result = vshll_n_u16(arg1, 6);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 0);
         exp = UINT64_C(0x0020000000312780);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 1);
         exp = UINT64_C(0x00383e4000000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1131() {

{
   {
      uint32x2_t arg1;
      uint64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"shl\", fnname = \"vshll_n_u32\", rettype = \"uint64x2_t\", argtypes = \"[uint32x2_t,__constrange(1,32) int]\", vals = [VectorVal [IntegerVal 2147516415,IntegerVal 4294934527],IndexVal 22], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_u32(UINT64_C(0xffff7fff80007fff));
      clear_neon_saturated();
      //  Expect: "result" = 003fffdfffc000000020001fffc00000
      result = vshll_n_u32(arg1, 22);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 0);
         exp = UINT64_C(0x0020001fffc00000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 1);
         exp = UINT64_C(0x003fffdfffc00000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1132() {

{
   {
      int8x16_t arg1;
      int16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"shl\", fnname = \"vshll_high_n_s8\", rettype = \"int16x8_t\", argtypes = \"[int8x16_t,__constrange(8,8) int]\", vals = [VectorVal [IntegerVal 50,IntegerVal (-1),IntegerVal 0,IntegerVal (-128),IntegerVal 127,IntegerVal (-1),IntegerVal (-72),IntegerVal (-1),IntegerVal 127,IntegerVal (-1),IntegerVal (-128),IntegerVal 127,IntegerVal (-47),IntegerVal (-128),IntegerVal 50,IntegerVal (-128)],IndexVal 8], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s8(vcreate_s8(UINT64_C(0xffb8ff7f8000ff32)),
                         vcreate_s8(UINT64_C(0x803280d17f80ff7f)));
      clear_neon_saturated();
      //  Expect: "result" = 800032008000d1007f008000ff007f00
      result = vshll_high_n_s8(arg1, 8);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 0);
         exp = UINT64_C(0x7f008000ff007f00);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 1);
         exp = UINT64_C(0x800032008000d100);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1133() {

{
   {
      int16x8_t arg1;
      int32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"shl\", fnname = \"vshll_high_n_s16\", rettype = \"int32x4_t\", argtypes = \"[int16x8_t,__constrange(16,16) int]\", vals = [VectorVal [IntegerVal 0,IntegerVal 32767,IntegerVal 0,IntegerVal 0,IntegerVal 0,IntegerVal 0,IntegerVal 0,IntegerVal 0],IndexVal 16], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s16(vcreate_s16(UINT64_C(0x000000007fff0000)),
                          vcreate_s16(0));
      clear_neon_saturated();
      //  Expect: "result" = 00000000000000000000000000000000
      result = vshll_high_n_s16(arg1, 16);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 0);
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 1);
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1134() {

{
   {
      int32x4_t arg1;
      int64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"shl\", fnname = \"vshll_high_n_s32\", rettype = \"int64x2_t\", argtypes = \"[int32x4_t,__constrange(32,32) int]\", vals = [VectorVal [IntegerVal (-1838821159),IntegerVal 32767,IntegerVal (-62787),IntegerVal 2147483647],IndexVal 32], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s32(vcreate_s32(UINT64_C(0x00007fff9265d0d9)),
                          vcreate_s32(UINT64_C(0x7fffffffffff0abd)));
      clear_neon_saturated();
      //  Expect: "result" = 7fffffff00000000ffff0abd00000000
      result = vshll_high_n_s32(arg1, 32);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 0);
         exp = UINT64_C(0xffff0abd00000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 1);
         exp = UINT64_C(0x7fffffff00000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1135() {

{
   {
      uint8x16_t arg1;
      uint16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"shl\", fnname = \"vshll_high_n_u8\", rettype = \"uint16x8_t\", argtypes = \"[uint8x16_t,__constrange(8,8) int]\", vals = [VectorVal [IntegerVal 128,IntegerVal 152,IntegerVal 0,IntegerVal 47,IntegerVal 127,IntegerVal 128,IntegerVal 244,IntegerVal 128,IntegerVal 127,IntegerVal 128,IntegerVal 255,IntegerVal 128,IntegerVal 255,IntegerVal 0,IntegerVal 244,IntegerVal 127],IndexVal 8], start_saturated = True}";
      int reported = 0;
      arg1 = vcombine_u8(vcreate_u8(UINT64_C(0x80f4807f2f009880)),
                         vcreate_u8(UINT64_C(0x7ff400ff80ff807f)));
      set_neon_saturated();
      //  Expect: "result" = 7f00f4000000ff008000ff0080007f00
      result = vshll_high_n_u8(arg1, 8);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 0);
         exp = UINT64_C(0x8000ff0080007f00);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 1);
         exp = UINT64_C(0x7f00f4000000ff00);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1136() {

{
   {
      uint16x8_t arg1;
      uint32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"shl\", fnname = \"vshll_high_n_u16\", rettype = \"uint32x4_t\", argtypes = \"[uint16x8_t,__constrange(16,16) int]\", vals = [VectorVal [IntegerVal 65535,IntegerVal 6436,IntegerVal 32767,IntegerVal 32768,IntegerVal 4045,IntegerVal 65535,IntegerVal 32767,IntegerVal 32767],IndexVal 16], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u16(vcreate_u16(UINT64_C(0x80007fff1924ffff)),
                          vcreate_u16(UINT64_C(0x7fff7fffffff0fcd)));
      clear_neon_saturated();
      //  Expect: "result" = 7fff00007fff0000ffff00000fcd0000
      result = vshll_high_n_u16(arg1, 16);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 0);
         exp = UINT64_C(0xffff00000fcd0000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 1);
         exp = UINT64_C(0x7fff00007fff0000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1137() {

{
   {
      uint32x4_t arg1;
      uint64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"shl\", fnname = \"vshll_high_n_u32\", rettype = \"uint64x2_t\", argtypes = \"[uint32x4_t,__constrange(32,32) int]\", vals = [VectorVal [IntegerVal 4294934528,IntegerVal 4294901760,IntegerVal 2147483648,IntegerVal 2147527900],IndexVal 32], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u32(vcreate_u32(UINT64_C(0xffff0000ffff8000)),
                          vcreate_u32(UINT64_C(0x8000acdc80000000)));
      clear_neon_saturated();
      //  Expect: "result" = 8000acdc000000008000000000000000
      result = vshll_high_n_u32(arg1, 32);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 0);
         exp = UINT64_C(0x8000000000000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 1);
         exp = UINT64_C(0x8000acdc00000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1138() {

{
   {
      int8x8_t arg1;
      int8x8_t arg2;
      int8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"sri\", fnname = \"vsri_n_s8\", rettype = \"int8x8_t\", argtypes = \"[int8x8_t,int8x8_t,__constrange(1,8) int]\", vals = [VectorVal [IntegerVal 9,IntegerVal 0,IntegerVal 0,IntegerVal (-93),IntegerVal (-1),IntegerVal 127,IntegerVal (-45),IntegerVal (-1)],VectorVal [IntegerVal 0,IntegerVal (-128),IntegerVal 38,IntegerVal (-128),IntegerVal (-128),IntegerVal (-1),IntegerVal 118,IntegerVal (-1)],IndexVal 8], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s8(UINT64_C(0xffd37fffa3000009));
      arg2 = vcreate_s8(UINT64_C(0xff76ff8080268000));
      clear_neon_saturated();
      //  Expect: "result" = ffd37fffa3000009
      result = vsri_n_s8(arg1, arg2, 8);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s8(result), 0);
      exp = UINT64_C(0xffd37fffa3000009);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1139() {

{
   {
      int16x4_t arg1;
      int16x4_t arg2;
      int16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"sri\", fnname = \"vsri_n_s16\", rettype = \"int16x4_t\", argtypes = \"[int16x4_t,int16x4_t,__constrange(1,16) int]\", vals = [VectorVal [IntegerVal 32767,IntegerVal 0,IntegerVal 0,IntegerVal 32767],VectorVal [IntegerVal 32767,IntegerVal 32767,IntegerVal 32767,IntegerVal 32767],IndexVal 3], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s16(UINT64_C(0x7fff000000007fff));
      arg2 = vcreate_s16(UINT64_C(0x7fff7fff7fff7fff));
      clear_neon_saturated();
      //  Expect: "result" = 6fff0fff0fff6fff
      result = vsri_n_s16(arg1, arg2, 3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s16(result), 0);
      exp = UINT64_C(0x6fff0fff0fff6fff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1140() {

{
   {
      int32x2_t arg1;
      int32x2_t arg2;
      int32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"sri\", fnname = \"vsri_n_s32\", rettype = \"int32x2_t\", argtypes = \"[int32x2_t,int32x2_t,__constrange(1,32) int]\", vals = [VectorVal [IntegerVal (-65536),IntegerVal (-1)],VectorVal [IntegerVal 2147450880,IntegerVal (-32768)],IndexVal 26], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s32(UINT64_C(0xffffffffffff0000));
      arg2 = vcreate_s32(UINT64_C(0xffff80007fff8000));
      clear_neon_saturated();
      //  Expect: "result" = ffffffffffff001f
      result = vsri_n_s32(arg1, arg2, 26);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s32(result), 0);
      exp = UINT64_C(0xffffffffffff001f);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1141() {

{
   {
      int64x1_t arg1;
      int64x1_t arg2;
      int64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"sri\", fnname = \"vsri_n_s64\", rettype = \"int64x1_t\", argtypes = \"[int64x1_t,int64x1_t,__constrange(1,64) int]\", vals = [VectorVal [IntegerVal (-9223231301513969664)],VectorVal [IntegerVal (-113567525273601)],IndexVal 27], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s64(UINT64_C(0x80007fff7fff0000));
      arg2 = vcreate_s64(UINT64_C(0xffff98b5ffff7fff));
      clear_neon_saturated();
      //  Expect: "result" = 80007ffffff316bf
      result = vsri_n_s64(arg1, arg2, 27);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s64(result), 0);
      exp = UINT64_C(0x80007ffffff316bf);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1142() {

{
   {
      uint8x8_t arg1;
      uint8x8_t arg2;
      uint8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"sri\", fnname = \"vsri_n_u8\", rettype = \"uint8x8_t\", argtypes = \"[uint8x8_t,uint8x8_t,__constrange(1,8) int]\", vals = [VectorVal [IntegerVal 0,IntegerVal 127,IntegerVal 24,IntegerVal 0,IntegerVal 127,IntegerVal 128,IntegerVal 148,IntegerVal 255],VectorVal [IntegerVal 69,IntegerVal 255,IntegerVal 128,IntegerVal 128,IntegerVal 128,IntegerVal 255,IntegerVal 58,IntegerVal 0],IndexVal 1], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u8(UINT64_C(0xff94807f00187f00));
      arg2 = vcreate_u8(UINT64_C(0x003aff808080ff45));
      clear_neon_saturated();
      //  Expect: "result" = 809dff4040407f22
      result = vsri_n_u8(arg1, arg2, 1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u8(result), 0);
      exp = UINT64_C(0x809dff4040407f22);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1143() {

{
   {
      uint16x4_t arg1;
      uint16x4_t arg2;
      uint16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"sri\", fnname = \"vsri_n_u16\", rettype = \"uint16x4_t\", argtypes = \"[uint16x4_t,uint16x4_t,__constrange(1,16) int]\", vals = [VectorVal [IntegerVal 32767,IntegerVal 0,IntegerVal 32768,IntegerVal 65535],VectorVal [IntegerVal 32767,IntegerVal 65535,IntegerVal 32768,IntegerVal 0],IndexVal 15], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u16(UINT64_C(0xffff800000007fff));
      arg2 = vcreate_u16(UINT64_C(0x00008000ffff7fff));
      clear_neon_saturated();
      //  Expect: "result" = fffe800100017ffe
      result = vsri_n_u16(arg1, arg2, 15);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u16(result), 0);
      exp = UINT64_C(0xfffe800100017ffe);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1144() {

{
   {
      uint32x2_t arg1;
      uint32x2_t arg2;
      uint32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"sri\", fnname = \"vsri_n_u32\", rettype = \"uint32x2_t\", argtypes = \"[uint32x2_t,uint32x2_t,__constrange(1,32) int]\", vals = [VectorVal [IntegerVal 4294901760,IntegerVal 2147513710],VectorVal [IntegerVal 2147516415,IntegerVal 2147549183],IndexVal 5], start_saturated = True}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u32(UINT64_C(0x8000756effff0000));
      arg2 = vcreate_u32(UINT64_C(0x8000ffff80007fff));
      set_neon_saturated();
      //  Expect: "result" = 840007fffc0003ff
      result = vsri_n_u32(arg1, arg2, 5);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u32(result), 0);
      exp = UINT64_C(0x840007fffc0003ff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1145() {

{
   {
      uint64x1_t arg1;
      uint64x1_t arg2;
      uint64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"sri\", fnname = \"vsri_n_u64\", rettype = \"uint64x1_t\", argtypes = \"[uint64x1_t,uint64x1_t,__constrange(1,64) int]\", vals = [VectorVal [IntegerVal 9223512770048196607],VectorVal [IntegerVal 9223489512423358463],IndexVal 30], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u64(UINT64_C(0x80007fff00007fff));
      arg2 = vcreate_u64(UINT64_C(0x80006ad7e988ffff));
      clear_neon_saturated();
      //  Expect: "result" = 80007ffe0001ab5f
      result = vsri_n_u64(arg1, arg2, 30);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(result, 0);
      exp = UINT64_C(0x80007ffe0001ab5f);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1146() {

{
   {
      poly8x8_t arg1;
      poly8x8_t arg2;
      poly8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"sri\", fnname = \"vsri_n_p8\", rettype = \"poly8x8_t\", argtypes = \"[poly8x8_t,poly8x8_t,__constrange(1,8) int]\", vals = [VectorVal [PolyVal [0,0,1,1,1,0,1,1],PolyVal [0,0,1,1,1,0,0,0],PolyVal [1,1,0,0,1,0,1,1],PolyVal [0,1,1,0,1,1,0,1],PolyVal [0,0,1,1,0,1,0,0],PolyVal [0,0,0,0,0,1,0,0],PolyVal [1,1,1,0,0,0,0,0],PolyVal [0,0,0,1,1,0,1,0]],VectorVal [PolyVal [1,1,1,0,1,0,1,0],PolyVal [0,1,1,1,1,1,1,1],PolyVal [0,0,1,0,1,0,0,1],PolyVal [1,0,0,0,1,0,1,1],PolyVal [1,1,0,0,1,1,1,0],PolyVal [1,0,0,0,1,1,0,1],PolyVal [1,1,1,1,1,1,0,1],PolyVal [1,1,1,1,0,0,0,0]],IndexVal 1], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_p8(UINT64_C(0x5807202cb6d31cdc));
      arg2 = vcreate_p8(UINT64_C(0x0fbfb173d194fe57));
      clear_neon_saturated();
      //  Expect: "result" = 075f5839e8ca7fab
      result = vsri_n_p8(arg1, arg2, 1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_p8(result), 0);
      exp = UINT64_C(0x075f5839e8ca7fab);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1147() {

{
   {
      poly16x4_t arg1;
      poly16x4_t arg2;
      poly16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"sri\", fnname = \"vsri_n_p16\", rettype = \"poly16x4_t\", argtypes = \"[poly16x4_t,poly16x4_t,__constrange(1,16) int]\", vals = [VectorVal [PolyVal [1,0,0,0,1,0,1,0,0,0,1,1,0,1,0,1],PolyVal [1,1,1,1,0,0,0,0,0,1,1,1,0,0,0,1],PolyVal [1,0,1,1,0,1,1,1,0,0,1,0,1,1,0,0],PolyVal [0,0,1,0,0,1,0,1,0,1,1,0,0,1,1,0]],VectorVal [PolyVal [1,1,1,0,0,1,1,1,0,1,1,1,0,0,1,1],PolyVal [0,1,1,1,0,0,0,0,0,0,1,1,1,0,1,1],PolyVal [0,0,0,0,1,0,0,1,1,0,0,0,1,1,0,1],PolyVal [0,0,0,0,1,0,1,0,0,0,0,0,0,1,1,1]],IndexVal 1], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_p16(UINT64_C(0x66a434ed8e0fac51));
      arg2 = vcreate_p16(UINT64_C(0xe050b190dc0ecee7));
      clear_neon_saturated();
      //  Expect: "result" = 702858c8ee07e773
      result = vsri_n_p16(arg1, arg2, 1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_p16(result), 0);
      exp = UINT64_C(0x702858c8ee07e773);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1148() {

{
   {
      int8x16_t arg1;
      int8x16_t arg2;
      int8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"sri\", fnname = \"vsriq_n_s8\", rettype = \"int8x16_t\", argtypes = \"[int8x16_t,int8x16_t,__constrange(1,8) int]\", vals = [VectorVal [IntegerVal 0,IntegerVal 0,IntegerVal 126,IntegerVal 0,IntegerVal 0,IntegerVal 127,IntegerVal 127,IntegerVal 127,IntegerVal (-128),IntegerVal (-128),IntegerVal 0,IntegerVal (-100),IntegerVal 127,IntegerVal (-27),IntegerVal 32,IntegerVal 127],VectorVal [IntegerVal (-128),IntegerVal (-128),IntegerVal 0,IntegerVal 127,IntegerVal (-128),IntegerVal 127,IntegerVal 0,IntegerVal (-1),IntegerVal 90,IntegerVal 127,IntegerVal 127,IntegerVal 0,IntegerVal (-128),IntegerVal (-119),IntegerVal (-43),IntegerVal (-93)],IndexVal 4], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s8(vcreate_s8(UINT64_C(0x7f7f7f00007e0000)),
                         vcreate_s8(UINT64_C(0x7f20e57f9c008080)));
      arg2 = vcombine_s8(vcreate_s8(UINT64_C(0xff007f807f008080)),
                         vcreate_s8(UINT64_C(0xa3d58980007f7f5a)));
      clear_neon_saturated();
      //  Expect: "result" = 7a2de878900787857f70770807700808
      result = vsriq_n_s8(arg1, arg2, 4);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result), 0);
         exp = UINT64_C(0x7f70770807700808);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result), 1);
         exp = UINT64_C(0x7a2de87890078785);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1149() {

{
   {
      int16x8_t arg1;
      int16x8_t arg2;
      int16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"sri\", fnname = \"vsriq_n_s16\", rettype = \"int16x8_t\", argtypes = \"[int16x8_t,int16x8_t,__constrange(1,16) int]\", vals = [VectorVal [IntegerVal (-32768),IntegerVal (-1),IntegerVal 32767,IntegerVal (-1),IntegerVal 32767,IntegerVal 32767,IntegerVal (-1),IntegerVal (-1)],VectorVal [IntegerVal 0,IntegerVal (-1),IntegerVal 0,IntegerVal (-18488),IntegerVal 14495,IntegerVal 16020,IntegerVal (-1),IntegerVal (-32768)],IndexVal 15], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s16(vcreate_s16(UINT64_C(0xffff7fffffff8000)),
                          vcreate_s16(UINT64_C(0xffffffff7fff7fff)));
      arg2 = vcombine_s16(vcreate_s16(UINT64_C(0xb7c80000ffff0000)),
                          vcreate_s16(UINT64_C(0x8000ffff3e94389f)));
      clear_neon_saturated();
      //  Expect: "result" = ffffffff7ffe7ffeffff7ffeffff8000
      result = vsriq_n_s16(arg1, arg2, 15);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 0);
         exp = UINT64_C(0xffff7ffeffff8000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 1);
         exp = UINT64_C(0xffffffff7ffe7ffe);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1150() {

{
   {
      int32x4_t arg1;
      int32x4_t arg2;
      int32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"sri\", fnname = \"vsriq_n_s32\", rettype = \"int32x4_t\", argtypes = \"[int32x4_t,int32x4_t,__constrange(1,32) int]\", vals = [VectorVal [IntegerVal (-2147427093),IntegerVal (-1),IntegerVal (-2147478668),IntegerVal 2147418112],VectorVal [IntegerVal (-2147483648),IntegerVal (-2147450880),IntegerVal 8426,IntegerVal (-1)],IndexVal 24], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s32(vcreate_s32(UINT64_C(0xffffffff8000dceb)),
                          vcreate_s32(UINT64_C(0x7fff000080001374)));
      arg2 = vcombine_s32(vcreate_s32(UINT64_C(0x8000800080000000)),
                          vcreate_s32(UINT64_C(0xffffffff000020ea)));
      clear_neon_saturated();
      //  Expect: "result" = 7fff00ff80001300ffffff808000dc80
      result = vsriq_n_s32(arg1, arg2, 24);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 0);
         exp = UINT64_C(0xffffff808000dc80);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 1);
         exp = UINT64_C(0x7fff00ff80001300);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1151() {

{
   {
      int64x2_t arg1;
      int64x2_t arg2;
      int64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"sri\", fnname = \"vsriq_n_s64\", rettype = \"int64x2_t\", argtypes = \"[int64x2_t,int64x2_t,__constrange(1,64) int]\", vals = [VectorVal [IntegerVal (-9223372032595586068),IntegerVal (-8294786084411801601)],VectorVal [IntegerVal 9223231296542808110,IntegerVal 9223231301513936896],IndexVal 14], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s64(vcreate_s64(UINT64_C(0x80000000fdde13ec)),
                          vcreate_s64(UINT64_C(0x8ce30000fec7ffff)));
      arg2 = vcombine_s64(vcreate_s64(UINT64_C(0x7fff7fff57b3182e)),
                          vcreate_s64(UINT64_C(0x7fff800080008000)));
      clear_neon_saturated();
      //  Expect: "result" = 8ce1fffe000200028001fffdfffd5ecc
      result = vsriq_n_s64(arg1, arg2, 14);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 0);
         exp = UINT64_C(0x8001fffdfffd5ecc);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 1);
         exp = UINT64_C(0x8ce1fffe00020002);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1152() {

{
   {
      uint8x16_t arg1;
      uint8x16_t arg2;
      uint8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"sri\", fnname = \"vsriq_n_u8\", rettype = \"uint8x16_t\", argtypes = \"[uint8x16_t,uint8x16_t,__constrange(1,8) int]\", vals = [VectorVal [IntegerVal 128,IntegerVal 127,IntegerVal 255,IntegerVal 187,IntegerVal 128,IntegerVal 255,IntegerVal 128,IntegerVal 127,IntegerVal 127,IntegerVal 255,IntegerVal 128,IntegerVal 128,IntegerVal 128,IntegerVal 255,IntegerVal 255,IntegerVal 0],VectorVal [IntegerVal 113,IntegerVal 255,IntegerVal 127,IntegerVal 127,IntegerVal 0,IntegerVal 0,IntegerVal 255,IntegerVal 128,IntegerVal 27,IntegerVal 192,IntegerVal 128,IntegerVal 0,IntegerVal 128,IntegerVal 0,IntegerVal 128,IntegerVal 128],IndexVal 2], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u8(vcreate_u8(UINT64_C(0x7f80ff80bbff7f80)),
                         vcreate_u8(UINT64_C(0x00ffff808080ff7f)));
      arg2 = vcombine_u8(vcreate_u8(UINT64_C(0x80ff00007f7fff71)),
                         vcreate_u8(UINT64_C(0x808000800080c01b)));
      clear_neon_saturated();
      //  Expect: "result" = 20e0c0a080a0f04660bfc0809fdf7f9c
      result = vsriq_n_u8(arg1, arg2, 2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 0);
         exp = UINT64_C(0x60bfc0809fdf7f9c);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 1);
         exp = UINT64_C(0x20e0c0a080a0f046);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1153() {

{
   {
      uint16x8_t arg1;
      uint16x8_t arg2;
      uint16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"sri\", fnname = \"vsriq_n_u16\", rettype = \"uint16x8_t\", argtypes = \"[uint16x8_t,uint16x8_t,__constrange(1,16) int]\", vals = [VectorVal [IntegerVal 32768,IntegerVal 0,IntegerVal 9674,IntegerVal 32768,IntegerVal 32767,IntegerVal 32768,IntegerVal 63587,IntegerVal 42933],VectorVal [IntegerVal 18391,IntegerVal 32767,IntegerVal 32768,IntegerVal 0,IntegerVal 57330,IntegerVal 65535,IntegerVal 32768,IntegerVal 32768],IndexVal 11], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u16(vcreate_u16(UINT64_C(0x800025ca00008000)),
                          vcreate_u16(UINT64_C(0xa7b5f86380007fff)));
      arg2 = vcombine_u16(vcreate_u16(UINT64_C(0x000080007fff47d7)),
                          vcreate_u16(UINT64_C(0x80008000ffffdff2)));
      clear_neon_saturated();
      //  Expect: "result" = a7b0f870801f7ffb800025d0000f8008
      result = vsriq_n_u16(arg1, arg2, 11);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 0);
         exp = UINT64_C(0x800025d0000f8008);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 1);
         exp = UINT64_C(0xa7b0f870801f7ffb);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1154() {

{
   {
      uint32x4_t arg1;
      uint32x4_t arg2;
      uint32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"sri\", fnname = \"vsriq_n_u32\", rettype = \"uint32x4_t\", argtypes = \"[uint32x4_t,uint32x4_t,__constrange(1,32) int]\", vals = [VectorVal [IntegerVal 2147483647,IntegerVal 2147483648,IntegerVal 2147450879,IntegerVal 4294934527],VectorVal [IntegerVal 2147450879,IntegerVal 2147483648,IntegerVal 2147549183,IntegerVal 2147418112],IndexVal 20], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u32(vcreate_u32(UINT64_C(0x800000007fffffff)),
                          vcreate_u32(UINT64_C(0xffff7fff7fff7fff)));
      arg2 = vcombine_u32(vcreate_u32(UINT64_C(0x800000007fff7fff)),
                          vcreate_u32(UINT64_C(0x7fff00008000ffff)));
      clear_neon_saturated();
      //  Expect: "result" = ffff77ff7fff7800800008007ffff7ff
      result = vsriq_n_u32(arg1, arg2, 20);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 0);
         exp = UINT64_C(0x800008007ffff7ff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 1);
         exp = UINT64_C(0xffff77ff7fff7800);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1155() {

{
   {
      uint64x2_t arg1;
      uint64x2_t arg2;
      uint64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"sri\", fnname = \"vsriq_n_u64\", rettype = \"uint64x2_t\", argtypes = \"[uint64x2_t,uint64x2_t,__constrange(1,64) int]\", vals = [VectorVal [IntegerVal 18446462600880309694,IntegerVal 18446462598732906495],VectorVal [IntegerVal 9223090563040215039,IntegerVal 163591009337343],IndexVal 1], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u64(vcreate_u64(UINT64_C(0xffff00007fffc5be)),
                          vcreate_u64(UINT64_C(0xffff00000000ffff)));
      arg2 = vcombine_u64(vcreate_u64(UINT64_C(0x7fff00004544ffff)),
                          vcreate_u64(UINT64_C(0x000094c8ffffffff)));
      clear_neon_saturated();
      //  Expect: "result" = 80004a647fffffffbfff800022a27fff
      result = vsriq_n_u64(arg1, arg2, 1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 0);
         exp = UINT64_C(0xbfff800022a27fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 1);
         exp = UINT64_C(0x80004a647fffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1156() {

{
   {
      poly8x16_t arg1;
      poly8x16_t arg2;
      poly8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"sri\", fnname = \"vsriq_n_p8\", rettype = \"poly8x16_t\", argtypes = \"[poly8x16_t,poly8x16_t,__constrange(1,8) int]\", vals = [VectorVal [PolyVal [0,1,0,0,0,1,0,1],PolyVal [0,0,0,0,1,0,1,1],PolyVal [1,0,0,1,1,0,0,1],PolyVal [0,1,1,1,0,1,0,1],PolyVal [0,1,1,0,1,1,0,1],PolyVal [1,0,0,0,1,0,0,1],PolyVal [0,0,0,1,1,1,1,0],PolyVal [0,1,1,1,0,0,0,0],PolyVal [0,0,1,1,1,1,0,1],PolyVal [0,0,0,0,1,1,0,0],PolyVal [1,0,1,1,1,1,1,0],PolyVal [0,1,1,1,0,0,1,0],PolyVal [0,1,1,1,0,1,1,0],PolyVal [0,0,0,0,1,1,1,1],PolyVal [0,1,1,0,1,0,1,0],PolyVal [0,1,1,0,1,0,0,1]],VectorVal [PolyVal [1,0,1,0,1,1,0,1],PolyVal [0,1,1,0,1,0,1,0],PolyVal [0,0,0,0,0,1,0,0],PolyVal [0,0,0,1,0,1,1,1],PolyVal [0,1,0,1,0,0,1,1],PolyVal [0,1,1,0,0,1,0,0],PolyVal [0,1,1,0,0,1,1,1],PolyVal [0,1,1,1,0,1,0,0],PolyVal [0,0,1,1,1,1,1,0],PolyVal [0,0,1,0,0,0,0,1],PolyVal [1,1,1,1,1,1,1,0],PolyVal [1,0,1,0,0,0,0,1],PolyVal [0,1,1,1,0,1,1,0],PolyVal [0,0,1,1,1,0,1,0],PolyVal [1,1,0,0,1,0,1,0],PolyVal [0,1,0,1,1,1,1,0]],IndexVal 3], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_p8(vcreate_p8(UINT64_C(0x0e7891b6ae99d0a2)),
                         vcreate_p8(UINT64_C(0x9656f06e4e7d30bc)));
      arg2 = vcombine_p8(vcreate_p8(UINT64_C(0x2ee626cae82056b5)),
                         vcreate_p8(UINT64_C(0x7a535c6e857f847c)));
      clear_neon_saturated();
      //  Expect: "result" = 8f4aeb6d506f30af057c84b9bd84cab6
      result = vsriq_n_p8(arg1, arg2, 3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p8(result), 0);
         exp = UINT64_C(0x057c84b9bd84cab6);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p8(result), 1);
         exp = UINT64_C(0x8f4aeb6d506f30af);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1157() {

{
   {
      poly16x8_t arg1;
      poly16x8_t arg2;
      poly16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"sri\", fnname = \"vsriq_n_p16\", rettype = \"poly16x8_t\", argtypes = \"[poly16x8_t,poly16x8_t,__constrange(1,16) int]\", vals = [VectorVal [PolyVal [0,0,1,0,1,0,0,1,0,1,0,0,1,1,1,0],PolyVal [1,0,0,1,0,1,0,0,0,1,0,1,1,1,1,1],PolyVal [0,0,1,0,0,1,0,0,1,1,0,0,1,0,0,1],PolyVal [0,0,0,1,0,0,1,1,0,1,1,0,1,0,1,1],PolyVal [1,0,1,1,1,1,1,1,1,1,1,1,1,0,0,1],PolyVal [0,0,1,1,0,0,0,0,0,1,1,0,0,1,1,0],PolyVal [0,1,0,0,0,0,1,1,0,1,1,1,0,1,0,0],PolyVal [1,0,1,1,1,0,1,1,1,1,1,1,0,0,0,1]],VectorVal [PolyVal [0,1,1,1,0,0,0,1,0,1,0,0,0,0,1,0],PolyVal [1,0,0,1,0,1,0,0,1,1,0,0,0,0,1,0],PolyVal [1,1,1,1,1,0,1,1,0,1,0,1,1,1,1,0],PolyVal [0,1,1,1,1,1,1,0,1,0,0,0,1,1,1,0],PolyVal [1,1,0,0,1,1,0,1,1,1,0,0,0,0,0,0],PolyVal [1,0,0,1,0,1,1,1,1,1,1,1,0,0,1,1],PolyVal [1,0,1,0,1,1,1,0,0,1,1,0,1,1,1,1],PolyVal [0,0,0,1,0,1,0,0,1,0,0,1,0,1,0,0]],IndexVal 16], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_p16(vcreate_p16(UINT64_C(0xd6c89324fa297294)),
                          vcreate_p16(UINT64_C(0x8fdd2ec2660c9ffd)));
      arg2 = vcombine_p16(vcreate_p16(UINT64_C(0x717e7adf4329428e)),
                          vcreate_p16(UINT64_C(0x2928f675cfe903b3)));
      clear_neon_saturated();
      //  Expect: "result" = 8fdd2ec2660c9ffdd6c89324fa297294
      result = vsriq_n_p16(arg1, arg2, 16);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p16(result), 0);
         exp = UINT64_C(0xd6c89324fa297294);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p16(result), 1);
         exp = UINT64_C(0x8fdd2ec2660c9ffd);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1158() {

{
   {
      int64_t arg1;
      int64_t arg2;
      int64_t result;
      char* str1 = "ReproInfo2 {semantics = \"sri\", fnname = \"vsrid_n_s64\", rettype = \"int64_t\", argtypes = \"[int64_t,int64_t,__constrange(1,64) int]\", vals = [IntegerVal 9223231295071485952,IntegerVal (-9223231299366387713),IndexVal 4], start_saturated = True}";
      int reported = 0;
      int64_t got;
      int64_t exp;
      arg1 = INT64_C(9223231295071485952);
      arg2 = INT64_C(-9223231299366387713);
      set_neon_saturated();
      //  Expect: "result" = 78000800000007ff
      result = vsrid_n_s64(arg1, arg2, 4);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      got = result;
      exp = INT64_C(8646920080644376575);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIi64 " Got: %" PRIi64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1159() {

{
   {
      uint64_t arg1;
      uint64_t arg2;
      uint64_t result;
      char* str1 = "ReproInfo2 {semantics = \"sri\", fnname = \"vsrid_n_u64\", rettype = \"uint64_t\", argtypes = \"[uint64_t,uint64_t,__constrange(1,64) int]\", vals = [IntegerVal 9223372039002248158,IntegerVal 4068439309094682623,IndexVal 26], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = UINT64_C(0x800000007fffd3de);
      arg2 = UINT64_C(0x3875ffff00d2ffff);
      clear_neon_saturated();
      //  Expect: "result" = 8000000e1d7fffc0
      result = vsrid_n_u64(arg1, arg2, 26);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = UINT64_C(0x8000000e1d7fffc0);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1160() {

{
   {
      int8x8_t arg1;
      int8x8_t arg2;
      int8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"sli\", fnname = \"vsli_n_s8\", rettype = \"int8x8_t\", argtypes = \"[int8x8_t,int8x8_t,__constrange(0,7) int]\", vals = [VectorVal [IntegerVal (-1),IntegerVal (-1),IntegerVal 127,IntegerVal (-1),IntegerVal 57,IntegerVal (-1),IntegerVal 14,IntegerVal 127],VectorVal [IntegerVal (-128),IntegerVal 0,IntegerVal 1,IntegerVal 0,IntegerVal 0,IntegerVal 0,IntegerVal 127,IntegerVal 24],IndexVal 7], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s8(UINT64_C(0x7f0eff39ff7fffff));
      arg2 = vcreate_s8(UINT64_C(0x187f000000010080));
      clear_neon_saturated();
      //  Expect: "result" = 7f8e7f397fff7f7f
      result = vsli_n_s8(arg1, arg2, 7);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s8(result), 0);
      exp = UINT64_C(0x7f8e7f397fff7f7f);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1161() {

{
   {
      int16x4_t arg1;
      int16x4_t arg2;
      int16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"sli\", fnname = \"vsli_n_s16\", rettype = \"int16x4_t\", argtypes = \"[int16x4_t,int16x4_t,__constrange(0,15) int]\", vals = [VectorVal [IntegerVal 8605,IntegerVal (-1),IntegerVal 0,IntegerVal 0],VectorVal [IntegerVal 21588,IntegerVal (-32768),IntegerVal 32767,IntegerVal 15949],IndexVal 0], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s16(UINT64_C(0x00000000ffff219d));
      arg2 = vcreate_s16(UINT64_C(0x3e4d7fff80005454));
      clear_neon_saturated();
      //  Expect: "result" = 3e4d7fff80005454
      result = vsli_n_s16(arg1, arg2, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s16(result), 0);
      exp = UINT64_C(0x3e4d7fff80005454);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1162() {

{
   {
      int32x2_t arg1;
      int32x2_t arg2;
      int32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"sli\", fnname = \"vsli_n_s32\", rettype = \"int32x2_t\", argtypes = \"[int32x2_t,int32x2_t,__constrange(0,31) int]\", vals = [VectorVal [IntegerVal 15614,IntegerVal 171704319],VectorVal [IntegerVal 32768,IntegerVal (-32769)],IndexVal 7], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s32(UINT64_C(0x0a3bffff00003cfe));
      arg2 = vcreate_s32(UINT64_C(0xffff7fff00008000));
      clear_neon_saturated();
      //  Expect: "result" = ffbfffff0040007e
      result = vsli_n_s32(arg1, arg2, 7);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s32(result), 0);
      exp = UINT64_C(0xffbfffff0040007e);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1163() {

{
   {
      int64x1_t arg1;
      int64x1_t arg2;
      int64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"sli\", fnname = \"vsli_n_s64\", rettype = \"int64x1_t\", argtypes = \"[int64x1_t,int64x1_t,__constrange(0,63) int]\", vals = [VectorVal [IntegerVal 9223231297219002367],VectorVal [IntegerVal 4294934527],IndexVal 2], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s64(UINT64_C(0x7fff7fff8000ffff));
      arg2 = vcreate_s64(UINT64_C(0x00000000ffff7fff));
      clear_neon_saturated();
      //  Expect: "result" = 00000003fffdffff
      result = vsli_n_s64(arg1, arg2, 2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s64(result), 0);
      exp = UINT64_C(0x00000003fffdffff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1164() {

{
   {
      uint8x8_t arg1;
      uint8x8_t arg2;
      uint8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"sli\", fnname = \"vsli_n_u8\", rettype = \"uint8x8_t\", argtypes = \"[uint8x8_t,uint8x8_t,__constrange(0,7) int]\", vals = [VectorVal [IntegerVal 255,IntegerVal 255,IntegerVal 156,IntegerVal 128,IntegerVal 255,IntegerVal 127,IntegerVal 255,IntegerVal 255],VectorVal [IntegerVal 255,IntegerVal 0,IntegerVal 75,IntegerVal 255,IntegerVal 134,IntegerVal 159,IntegerVal 153,IntegerVal 127],IndexVal 6], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u8(UINT64_C(0xffff7fff809cffff));
      arg2 = vcreate_u8(UINT64_C(0x7f999f86ff4b00ff));
      clear_neon_saturated();
      //  Expect: "result" = ff7fffbfc0dc3fff
      result = vsli_n_u8(arg1, arg2, 6);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u8(result), 0);
      exp = UINT64_C(0xff7fffbfc0dc3fff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1165() {

{
   {
      uint16x4_t arg1;
      uint16x4_t arg2;
      uint16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"sli\", fnname = \"vsli_n_u16\", rettype = \"uint16x4_t\", argtypes = \"[uint16x4_t,uint16x4_t,__constrange(0,15) int]\", vals = [VectorVal [IntegerVal 42171,IntegerVal 65535,IntegerVal 32768,IntegerVal 0],VectorVal [IntegerVal 0,IntegerVal 32768,IntegerVal 32768,IntegerVal 32768],IndexVal 15], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u16(UINT64_C(0x00008000ffffa4bb));
      arg2 = vcreate_u16(UINT64_C(0x8000800080000000));
      clear_neon_saturated();
      //  Expect: "result" = 000000007fff24bb
      result = vsli_n_u16(arg1, arg2, 15);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u16(result), 0);
      exp = UINT64_C(0x000000007fff24bb);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1166() {

{
   {
      uint32x2_t arg1;
      uint32x2_t arg2;
      uint32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"sli\", fnname = \"vsli_n_u32\", rettype = \"uint32x2_t\", argtypes = \"[uint32x2_t,uint32x2_t,__constrange(0,31) int]\", vals = [VectorVal [IntegerVal 2147450879,IntegerVal 4294967295],VectorVal [IntegerVal 4294934528,IntegerVal 3597991935],IndexVal 24], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u32(UINT64_C(0xffffffff7fff7fff));
      arg2 = vcreate_u32(UINT64_C(0xd674ffffffff8000));
      clear_neon_saturated();
      //  Expect: "result" = ffffffff00ff7fff
      result = vsli_n_u32(arg1, arg2, 24);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u32(result), 0);
      exp = UINT64_C(0xffffffff00ff7fff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1167() {

{
   {
      uint64x1_t arg1;
      uint64x1_t arg2;
      uint64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"sli\", fnname = \"vsli_n_u64\", rettype = \"uint64x1_t\", argtypes = \"[uint64x1_t,uint64x1_t,__constrange(0,63) int]\", vals = [VectorVal [IntegerVal 18446717408405028864],VectorVal [IntegerVal 9223372040363671552],IndexVal 55], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u64(UINT64_C(0xffffe7bf7fff0000));
      arg2 = vcreate_u64(UINT64_C(0x80000000d1258000));
      clear_neon_saturated();
      //  Expect: "result" = 007fe7bf7fff0000
      result = vsli_n_u64(arg1, arg2, 55);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(result, 0);
      exp = UINT64_C(0x007fe7bf7fff0000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1168() {

{
   {
      poly8x8_t arg1;
      poly8x8_t arg2;
      poly8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"sli\", fnname = \"vsli_n_p8\", rettype = \"poly8x8_t\", argtypes = \"[poly8x8_t,poly8x8_t,__constrange(0,7) int]\", vals = [VectorVal [PolyVal [0,1,0,1,1,1,0,1],PolyVal [0,0,1,1,0,0,0,1],PolyVal [1,0,1,1,1,1,0,1],PolyVal [1,0,1,1,1,0,0,0],PolyVal [0,0,0,0,1,0,1,1],PolyVal [0,0,1,1,0,1,0,1],PolyVal [1,0,0,1,1,1,1,1],PolyVal [1,1,1,0,1,1,1,0]],VectorVal [PolyVal [1,1,0,1,0,1,0,0],PolyVal [0,1,0,0,1,0,1,1],PolyVal [1,1,0,0,0,1,0,1],PolyVal [1,1,0,0,0,1,0,1],PolyVal [1,0,1,0,1,0,0,0],PolyVal [0,1,1,1,1,0,0,1],PolyVal [1,1,1,1,0,0,0,0],PolyVal [1,1,0,1,1,0,0,1]],IndexVal 0], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_p8(UINT64_C(0x77f9acd01dbd8cba));
      arg2 = vcreate_p8(UINT64_C(0x9b0f9e15a3a3d22b));
      clear_neon_saturated();
      //  Expect: "result" = 9b0f9e15a3a3d22b
      result = vsli_n_p8(arg1, arg2, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_p8(result), 0);
      exp = UINT64_C(0x9b0f9e15a3a3d22b);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1169() {

{
   {
      poly16x4_t arg1;
      poly16x4_t arg2;
      poly16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"sli\", fnname = \"vsli_n_p16\", rettype = \"poly16x4_t\", argtypes = \"[poly16x4_t,poly16x4_t,__constrange(0,15) int]\", vals = [VectorVal [PolyVal [1,0,1,0,1,1,0,0,0,1,1,0,1,1,1,1],PolyVal [0,0,1,1,1,1,0,1,1,0,1,0,0,0,1,0],PolyVal [0,1,0,0,1,1,0,1,0,0,1,1,1,0,0,1],PolyVal [0,1,0,1,0,0,1,1,1,1,1,0,1,1,0,0]],VectorVal [PolyVal [0,0,0,0,0,1,0,0,0,1,1,1,0,1,1,0],PolyVal [1,1,0,1,1,1,0,0,0,1,0,0,1,1,0,1],PolyVal [0,1,1,1,0,0,0,0,0,1,1,0,0,1,0,1],PolyVal [0,0,0,1,1,0,1,0,0,1,1,1,0,1,0,1]],IndexVal 7], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_p16(UINT64_C(0x37ca9cb245bcf635));
      arg2 = vcreate_p16(UINT64_C(0xae58a60eb23b6e20));
      clear_neon_saturated();
      //  Expect: "result" = 2c4a07321dbc1035
      result = vsli_n_p16(arg1, arg2, 7);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_p16(result), 0);
      exp = UINT64_C(0x2c4a07321dbc1035);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1170() {

{
   {
      int8x16_t arg1;
      int8x16_t arg2;
      int8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"sli\", fnname = \"vsliq_n_s8\", rettype = \"int8x16_t\", argtypes = \"[int8x16_t,int8x16_t,__constrange(0,7) int]\", vals = [VectorVal [IntegerVal (-128),IntegerVal 78,IntegerVal 127,IntegerVal 0,IntegerVal (-59),IntegerVal 3,IntegerVal (-68),IntegerVal 88,IntegerVal 127,IntegerVal 0,IntegerVal 127,IntegerVal (-128),IntegerVal 114,IntegerVal (-1),IntegerVal 93,IntegerVal (-128)],VectorVal [IntegerVal (-88),IntegerVal (-1),IntegerVal 127,IntegerVal (-96),IntegerVal (-1),IntegerVal 101,IntegerVal (-128),IntegerVal 87,IntegerVal (-62),IntegerVal (-1),IntegerVal 127,IntegerVal 0,IntegerVal 0,IntegerVal (-128),IntegerVal (-128),IntegerVal (-128)],IndexVal 0], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s8(vcreate_s8(UINT64_C(0x58bc03c5007f4e80)),
                         vcreate_s8(UINT64_C(0x805dff72807f007f)));
      arg2 = vcombine_s8(vcreate_s8(UINT64_C(0x578065ffa07fffa8)),
                         vcreate_s8(UINT64_C(0x80808000007fffc2)));
      clear_neon_saturated();
      //  Expect: "result" = 80808000007fffc2578065ffa07fffa8
      result = vsliq_n_s8(arg1, arg2, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result), 0);
         exp = UINT64_C(0x578065ffa07fffa8);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result), 1);
         exp = UINT64_C(0x80808000007fffc2);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1171() {

{
   {
      int16x8_t arg1;
      int16x8_t arg2;
      int16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"sli\", fnname = \"vsliq_n_s16\", rettype = \"int16x8_t\", argtypes = \"[int16x8_t,int16x8_t,__constrange(0,15) int]\", vals = [VectorVal [IntegerVal 32767,IntegerVal (-1),IntegerVal 32767,IntegerVal 0,IntegerVal (-32768),IntegerVal 32767,IntegerVal (-32768),IntegerVal (-32768)],VectorVal [IntegerVal (-32768),IntegerVal 0,IntegerVal 32767,IntegerVal 0,IntegerVal (-1),IntegerVal 32767,IntegerVal 0,IntegerVal (-32768)],IndexVal 5], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s16(vcreate_s16(UINT64_C(0x00007fffffff7fff)),
                          vcreate_s16(UINT64_C(0x800080007fff8000)));
      arg2 = vcombine_s16(vcreate_s16(UINT64_C(0x00007fff00008000)),
                          vcreate_s16(UINT64_C(0x800000007fffffff)));
      clear_neon_saturated();
      //  Expect: "result" = 00000000ffffffe00000ffff001f001f
      result = vsliq_n_s16(arg1, arg2, 5);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 0);
         exp = UINT64_C(0x0000ffff001f001f);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 1);
         exp = UINT64_C(0x00000000ffffffe0);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1172() {

{
   {
      int32x4_t arg1;
      int32x4_t arg2;
      int32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"sli\", fnname = \"vsliq_n_s32\", rettype = \"int32x4_t\", argtypes = \"[int32x4_t,int32x4_t,__constrange(0,31) int]\", vals = [VectorVal [IntegerVal (-2147483648),IntegerVal (-1),IntegerVal (-32768),IntegerVal (-1646428161)],VectorVal [IntegerVal 32768,IntegerVal 0,IntegerVal 32768,IntegerVal (-1033863169)],IndexVal 20], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s32(vcreate_s32(UINT64_C(0xffffffff80000000)),
                          vcreate_s32(UINT64_C(0x9ddd7fffffff8000)));
      arg2 = vcombine_s32(vcreate_s32(UINT64_C(0x0000000000008000)),
                          vcreate_s32(UINT64_C(0xc2607fff00008000)));
      clear_neon_saturated();
      //  Expect: "result" = fffd7fff000f8000000fffff00000000
      result = vsliq_n_s32(arg1, arg2, 20);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 0);
         exp = UINT64_C(0x000fffff00000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 1);
         exp = UINT64_C(0xfffd7fff000f8000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1173() {

{
   {
      int64x2_t arg1;
      int64x2_t arg2;
      int64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"sli\", fnname = \"vsliq_n_s64\", rettype = \"int64x2_t\", argtypes = \"[int64x2_t,int64x2_t,__constrange(0,63) int]\", vals = [VectorVal [IntegerVal (-9223231295071518720),IntegerVal 196271415558143],VectorVal [IntegerVal (-9223231299366453248),IntegerVal 9223090565825429503],IndexVal 37], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s64(vcreate_s64(UINT64_C(0x80008000ffff0000)),
                          vcreate_s64(UINT64_C(0x0000b2820000ffff)));
      arg2 = vcombine_s64(vcreate_s64(UINT64_C(0x80007fffffff8000)),
                          vcreate_s64(UINT64_C(0x7fff0000eb47ffff)));
      clear_neon_saturated();
      //  Expect: "result" = 68ffffe20000fffffff00000ffff0000
      result = vsliq_n_s64(arg1, arg2, 37);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 0);
         exp = UINT64_C(0xfff00000ffff0000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 1);
         exp = UINT64_C(0x68ffffe20000ffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1174() {

{
   {
      uint8x16_t arg1;
      uint8x16_t arg2;
      uint8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"sli\", fnname = \"vsliq_n_u8\", rettype = \"uint8x16_t\", argtypes = \"[uint8x16_t,uint8x16_t,__constrange(0,7) int]\", vals = [VectorVal [IntegerVal 127,IntegerVal 127,IntegerVal 255,IntegerVal 127,IntegerVal 128,IntegerVal 0,IntegerVal 255,IntegerVal 134,IntegerVal 127,IntegerVal 127,IntegerVal 128,IntegerVal 128,IntegerVal 128,IntegerVal 93,IntegerVal 128,IntegerVal 128],VectorVal [IntegerVal 128,IntegerVal 255,IntegerVal 127,IntegerVal 128,IntegerVal 31,IntegerVal 0,IntegerVal 96,IntegerVal 255,IntegerVal 0,IntegerVal 128,IntegerVal 0,IntegerVal 42,IntegerVal 0,IntegerVal 251,IntegerVal 0,IntegerVal 127],IndexVal 6], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u8(vcreate_u8(UINT64_C(0x86ff00807fff7f7f)),
                         vcreate_u8(UINT64_C(0x80805d8080807f7f)));
      arg2 = vcombine_u8(vcreate_u8(UINT64_C(0xff60001f807fff80)),
                         vcreate_u8(UINT64_C(0x7f00fb002a008000)));
      clear_neon_saturated();
      //  Expect: "result" = c000dd0080003f3fc63f00c03fffff3f
      result = vsliq_n_u8(arg1, arg2, 6);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 0);
         exp = UINT64_C(0xc63f00c03fffff3f);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 1);
         exp = UINT64_C(0xc000dd0080003f3f);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1175() {

{
   {
      uint16x8_t arg1;
      uint16x8_t arg2;
      uint16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"sli\", fnname = \"vsliq_n_u16\", rettype = \"uint16x8_t\", argtypes = \"[uint16x8_t,uint16x8_t,__constrange(0,15) int]\", vals = [VectorVal [IntegerVal 32768,IntegerVal 32768,IntegerVal 0,IntegerVal 16209,IntegerVal 65535,IntegerVal 0,IntegerVal 45674,IntegerVal 32767],VectorVal [IntegerVal 32768,IntegerVal 37719,IntegerVal 32767,IntegerVal 32767,IntegerVal 0,IntegerVal 44265,IntegerVal 32768,IntegerVal 0],IndexVal 11], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u16(vcreate_u16(UINT64_C(0x3f51000080008000)),
                          vcreate_u16(UINT64_C(0x7fffb26a0000ffff)));
      arg2 = vcombine_u16(vcreate_u16(UINT64_C(0x7fff7fff93578000)),
                          vcreate_u16(UINT64_C(0x00008000ace90000)));
      clear_neon_saturated();
      //  Expect: "result" = 07ff026a480007ffff51f800b8000000
      result = vsliq_n_u16(arg1, arg2, 11);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 0);
         exp = UINT64_C(0xff51f800b8000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 1);
         exp = UINT64_C(0x07ff026a480007ff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1176() {

{
   {
      uint32x4_t arg1;
      uint32x4_t arg2;
      uint32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"sli\", fnname = \"vsliq_n_u32\", rettype = \"uint32x4_t\", argtypes = \"[uint32x4_t,uint32x4_t,__constrange(0,31) int]\", vals = [VectorVal [IntegerVal 2147516415,IntegerVal 4294963110,IntegerVal 2147450880,IntegerVal 2147516416],VectorVal [IntegerVal 3881041919,IntegerVal 4294901760,IntegerVal 2147483648,IntegerVal 2147549183],IndexVal 23], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u32(vcreate_u32(UINT64_C(0xffffefa680007fff)),
                          vcreate_u32(UINT64_C(0x800080007fff8000)));
      arg2 = vcombine_u32(vcreate_u32(UINT64_C(0xffff0000e753ffff)),
                          vcreate_u32(UINT64_C(0x8000ffff80000000)));
      clear_neon_saturated();
      //  Expect: "result" = ff808000007f8000007fefa6ff807fff
      result = vsliq_n_u32(arg1, arg2, 23);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 0);
         exp = UINT64_C(0x007fefa6ff807fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 1);
         exp = UINT64_C(0xff808000007f8000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1177() {

{
   {
      uint64x2_t arg1;
      uint64x2_t arg2;
      uint64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"sli\", fnname = \"vsliq_n_u64\", rettype = \"uint64x2_t\", argtypes = \"[uint64x2_t,uint64x2_t,__constrange(0,63) int]\", vals = [VectorVal [IntegerVal 18446744071027163135,IntegerVal 9223231295071453184],VectorVal [IntegerVal 9223503600292954111,IntegerVal 9223434017527889025],IndexVal 43], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u64(vcreate_u64(UINT64_C(0xffffffff601dffff)),
                          vcreate_u64(UINT64_C(0x7fff7fff00000000)));
      arg2 = vcombine_u64(vcreate_u64(UINT64_C(0x800077a7ffff7fff)),
                          vcreate_u64(UINT64_C(0x8000385f0000fc81)));
      clear_neon_saturated();
      //  Expect: "result" = 07e40fff00000000fbffffff601dffff
      result = vsliq_n_u64(arg1, arg2, 43);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 0);
         exp = UINT64_C(0xfbffffff601dffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 1);
         exp = UINT64_C(0x07e40fff00000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1178() {

{
   {
      poly8x16_t arg1;
      poly8x16_t arg2;
      poly8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"sli\", fnname = \"vsliq_n_p8\", rettype = \"poly8x16_t\", argtypes = \"[poly8x16_t,poly8x16_t,__constrange(0,7) int]\", vals = [VectorVal [PolyVal [0,0,0,0,0,1,0,0],PolyVal [1,0,1,0,0,0,0,1],PolyVal [1,0,1,0,1,1,1,0],PolyVal [0,0,0,1,1,0,0,1],PolyVal [0,1,0,1,1,1,0,1],PolyVal [1,1,0,0,1,1,0,0],PolyVal [0,1,0,1,1,1,0,0],PolyVal [1,0,1,0,1,1,0,1],PolyVal [0,1,1,1,1,0,0,0],PolyVal [1,1,0,1,1,1,0,0],PolyVal [0,1,1,1,1,0,0,0],PolyVal [0,0,0,1,0,1,0,1],PolyVal [0,1,0,0,0,1,0,1],PolyVal [1,0,1,0,1,0,1,0],PolyVal [1,1,1,0,1,1,1,0],PolyVal [0,0,1,0,0,0,0,1]],VectorVal [PolyVal [1,1,1,1,0,0,0,1],PolyVal [1,1,0,1,0,1,0,0],PolyVal [0,0,1,1,1,1,0,1],PolyVal [1,1,0,1,0,0,1,0],PolyVal [1,0,1,0,1,0,1,1],PolyVal [1,1,1,1,1,1,0,0],PolyVal [0,0,0,0,1,1,0,1],PolyVal [1,1,0,1,0,0,1,0],PolyVal [0,1,0,1,0,1,0,1],PolyVal [1,0,0,0,1,0,0,1],PolyVal [1,1,0,0,1,0,1,1],PolyVal [1,0,0,1,1,0,0,0],PolyVal [1,1,1,0,1,1,0,1],PolyVal [0,1,0,1,1,0,1,0],PolyVal [1,0,0,1,1,1,0,0],PolyVal [1,1,0,0,1,1,0,0]],IndexVal 2], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_p8(vcreate_p8(UINT64_C(0xb53a33ba98758520)),
                         vcreate_p8(UINT64_C(0x847755a2a81e3b1e)));
      arg2 = vcombine_p8(vcreate_p8(UINT64_C(0x4bb03fd54bbc2b8f)),
                         vcreate_p8(UINT64_C(0x33395ab719d391aa)));
      clear_neon_saturated();
      //  Expect: "result" = cce769de644e47aa2dc2ff562cf1ad3c
      result = vsliq_n_p8(arg1, arg2, 2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p8(result), 0);
         exp = UINT64_C(0x2dc2ff562cf1ad3c);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p8(result), 1);
         exp = UINT64_C(0xcce769de644e47aa);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1179() {

{
   {
      poly16x8_t arg1;
      poly16x8_t arg2;
      poly16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"sli\", fnname = \"vsliq_n_p16\", rettype = \"poly16x8_t\", argtypes = \"[poly16x8_t,poly16x8_t,__constrange(0,15) int]\", vals = [VectorVal [PolyVal [0,1,1,0,0,1,1,0,1,0,0,1,0,1,0,0],PolyVal [1,0,0,0,1,0,1,1,1,0,0,0,0,0,0,0],PolyVal [0,0,0,0,1,1,0,0,0,1,0,0,0,0,1,0],PolyVal [1,0,0,0,1,0,0,1,1,0,0,1,1,0,1,1],PolyVal [0,1,0,1,1,0,1,0,1,1,0,0,0,0,1,0],PolyVal [0,1,0,0,0,0,0,0,1,0,1,1,1,1,1,1],PolyVal [1,1,0,0,1,1,0,1,0,1,0,1,0,0,0,1],PolyVal [1,0,0,1,1,0,0,0,1,1,1,1,1,1,0,1]],VectorVal [PolyVal [1,0,0,1,0,1,1,1,1,1,0,0,1,1,0,0],PolyVal [0,1,0,0,0,0,1,1,1,0,1,1,0,0,0,0],PolyVal [1,0,1,0,1,1,0,0,0,0,0,1,1,1,0,0],PolyVal [1,1,0,0,1,0,0,1,0,1,0,0,1,0,0,1],PolyVal [0,0,0,1,0,1,0,0,1,0,0,1,1,0,1,1],PolyVal [0,0,1,1,1,1,1,0,0,0,0,0,1,0,1,1],PolyVal [1,1,0,0,0,1,0,1,1,0,0,0,0,0,1,0],PolyVal [1,0,0,0,1,1,0,1,0,1,1,1,0,0,0,1]],IndexVal 1], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_p16(vcreate_p16(UINT64_C(0xd991423001d12966)),
                          vcreate_p16(UINT64_C(0xbf198ab3fd02435a)));
      arg2 = vcombine_p16(vcreate_p16(UINT64_C(0x929338350dc233e9)),
                          vcreate_p16(UINT64_C(0x8eb141a3d07cd928)));
      clear_neon_saturated();
      //  Expect: "result" = 1d638347a0f8b2502527706a1b8567d2
      result = vsliq_n_p16(arg1, arg2, 1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p16(result), 0);
         exp = UINT64_C(0x2527706a1b8567d2);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p16(result), 1);
         exp = UINT64_C(0x1d638347a0f8b250);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1180() {

{
   {
      int64_t arg1;
      int64_t arg2;
      int64_t result;
      char* str1 = "ReproInfo2 {semantics = \"sli\", fnname = \"vslid_n_s64\", rettype = \"int64_t\", argtypes = \"[int64_t,int64_t,__constrange(0,63) int]\", vals = [IntegerVal (-9223090566172999681),IntegerVal 140737488381370,IndexVal 7], start_saturated = False}";
      int reported = 0;
      int64_t got;
      int64_t exp;
      arg1 = INT64_C(-9223090566172999681);
      arg2 = INT64_C(140737488381370);
      clear_neon_saturated();
      //  Expect: "result" = 004000000032dd7f
      result = vslid_n_s64(arg1, arg2, 7);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = INT64_C(18014398512815487);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIi64 " Got: %" PRIi64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1181() {

{
   {
      uint64_t arg1;
      uint64_t arg2;
      uint64_t result;
      char* str1 = "ReproInfo2 {semantics = \"sli\", fnname = \"vslid_n_u64\", rettype = \"uint64_t\", argtypes = \"[uint64_t,uint64_t,__constrange(0,63) int]\", vals = [IntegerVal 1055390429471541301,IntegerVal 9223090561878130687,IndexVal 18], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = UINT64_C(0x0ea58000ffff8835);
      arg2 = UINT64_C(0x7fff00000000ffff);
      clear_neon_saturated();
      //  Expect: "result" = 00000003ffff8835
      result = vslid_n_u64(arg1, arg2, 18);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = UINT64_C(0x00000003ffff8835);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1182() {

{
   {
      uint8_t arg1[16];
      uint8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"load1\", fnname = \"vld1q_u8\", rettype = \"uint8x16_t\", argtypes = \"[__transfersize(16) uint8_t const *]\", vals = [PtrVal [IntegerVal 128,IntegerVal 255,IntegerVal 128,IntegerVal 69,IntegerVal 172,IntegerVal 255,IntegerVal 42,IntegerVal 255,IntegerVal 128,IntegerVal 210,IntegerVal 0,IntegerVal 0,IntegerVal 241,IntegerVal 127,IntegerVal 0,IntegerVal 255]], start_saturated = False}";
      int reported = 0;
      arg1[0] = 128U;
      arg1[1] = 255U;
      arg1[2] = 128U;
      arg1[3] = 69U;
      arg1[4] = 172U;
      arg1[5] = 255U;
      arg1[6] = 42U;
      arg1[7] = 255U;
      arg1[8] = 128U;
      arg1[9] = 210U;
      arg1[10] = 0;
      arg1[11] = 0;
      arg1[12] = 241U;
      arg1[13] = 127U;
      arg1[14] = 0;
      arg1[15] = 255U;
      clear_neon_saturated();
      //  Expect: "result" = ff007ff10000d280ff2affac4580ff80
      result = vld1q_u8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 0);
         exp = UINT64_C(0xff2affac4580ff80);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 1);
         exp = UINT64_C(0xff007ff10000d280);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1183() {

{
   {
      uint16_t arg1[8];
      uint16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"load1\", fnname = \"vld1q_u16\", rettype = \"uint16x8_t\", argtypes = \"[__transfersize(8) uint16_t const *]\", vals = [PtrVal [IntegerVal 65535,IntegerVal 65535,IntegerVal 32767,IntegerVal 41708,IntegerVal 63741,IntegerVal 54472,IntegerVal 65535,IntegerVal 32767]], start_saturated = False}";
      int reported = 0;
      arg1[0] = 65535U;
      arg1[1] = 65535U;
      arg1[2] = 32767U;
      arg1[3] = 41708U;
      arg1[4] = 63741U;
      arg1[5] = 54472U;
      arg1[6] = 65535U;
      arg1[7] = 32767U;
      clear_neon_saturated();
      //  Expect: "result" = 7fffffffd4c8f8fda2ec7fffffffffff
      result = vld1q_u16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 0);
         exp = UINT64_C(0xa2ec7fffffffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 1);
         exp = UINT64_C(0x7fffffffd4c8f8fd);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1184() {

{
   {
      uint32_t arg1[4];
      uint32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"load1\", fnname = \"vld1q_u32\", rettype = \"uint32x4_t\", argtypes = \"[__transfersize(4) uint32_t const *]\", vals = [PtrVal [IntegerVal 32768,IntegerVal 2147418112,IntegerVal 0,IntegerVal 2147483648]], start_saturated = False}";
      int reported = 0;
      arg1[0] = 32768U;
      arg1[1] = 2147418112U;
      arg1[2] = 0;
      arg1[3] = 2147483648U;
      clear_neon_saturated();
      //  Expect: "result" = 80000000000000007fff000000008000
      result = vld1q_u32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 0);
         exp = UINT64_C(0x7fff000000008000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 1);
         exp = UINT64_C(0x8000000000000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1185() {

{
   {
      uint64_t arg1[2];
      uint64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"load1\", fnname = \"vld1q_u64\", rettype = \"uint64x2_t\", argtypes = \"[__transfersize(2) uint64_t const *]\", vals = [PtrVal [IntegerVal 18446540122892566528,IntegerVal 9223372034707259391]], start_saturated = False}";
      int reported = 0;
      arg1[0] = UINT64_C(0xffff468200008000);
      arg1[1] = UINT64_C(0x7fffffff7fff7fff);
      clear_neon_saturated();
      //  Expect: "result" = 7fffffff7fff7fffffff468200008000
      result = vld1q_u64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 0);
         exp = UINT64_C(0xffff468200008000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 1);
         exp = UINT64_C(0x7fffffff7fff7fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1186() {

{
   {
      int8_t arg1[16];
      int8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"load1\", fnname = \"vld1q_s8\", rettype = \"int8x16_t\", argtypes = \"[__transfersize(16) int8_t const *]\", vals = [PtrVal [IntegerVal 127,IntegerVal (-1),IntegerVal 127,IntegerVal 127,IntegerVal (-1),IntegerVal 127,IntegerVal (-128),IntegerVal 0,IntegerVal (-1),IntegerVal (-83),IntegerVal (-34),IntegerVal (-128),IntegerVal 0,IntegerVal (-128),IntegerVal (-1),IntegerVal 0]], start_saturated = False}";
      int reported = 0;
      arg1[0] = 127;
      arg1[1] = -1;
      arg1[2] = 127;
      arg1[3] = 127;
      arg1[4] = -1;
      arg1[5] = 127;
      arg1[6] = -128;
      arg1[7] = 0;
      arg1[8] = -1;
      arg1[9] = -83;
      arg1[10] = -34;
      arg1[11] = -128;
      arg1[12] = 0;
      arg1[13] = -128;
      arg1[14] = -1;
      arg1[15] = 0;
      clear_neon_saturated();
      //  Expect: "result" = 00ff800080deadff00807fff7f7fff7f
      result = vld1q_s8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result), 0);
         exp = UINT64_C(0x00807fff7f7fff7f);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result), 1);
         exp = UINT64_C(0x00ff800080deadff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1187() {

{
   {
      int16_t arg1[8];
      int16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"load1\", fnname = \"vld1q_s16\", rettype = \"int16x8_t\", argtypes = \"[__transfersize(8) int16_t const *]\", vals = [PtrVal [IntegerVal (-1),IntegerVal (-31861),IntegerVal 32767,IntegerVal (-32768),IntegerVal (-32768),IntegerVal (-32768),IntegerVal (-9055),IntegerVal (-1)]], start_saturated = False}";
      int reported = 0;
      arg1[0] = -1;
      arg1[1] = -31861;
      arg1[2] = 32767;
      arg1[3] = -32768;
      arg1[4] = -32768;
      arg1[5] = -32768;
      arg1[6] = -9055;
      arg1[7] = -1;
      clear_neon_saturated();
      //  Expect: "result" = ffffdca18000800080007fff838bffff
      result = vld1q_s16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 0);
         exp = UINT64_C(0x80007fff838bffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 1);
         exp = UINT64_C(0xffffdca180008000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1188() {

{
   {
      int32_t arg1[4];
      int32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"load1\", fnname = \"vld1q_s32\", rettype = \"int32x4_t\", argtypes = \"[__transfersize(4) int32_t const *]\", vals = [PtrVal [IntegerVal 0,IntegerVal 32768,IntegerVal 730169344,IntegerVal (-1)]], start_saturated = False}";
      int reported = 0;
      arg1[0] = 0;
      arg1[1] = 32768;
      arg1[2] = 730169344;
      arg1[3] = -1;
      clear_neon_saturated();
      //  Expect: "result" = ffffffff2b8580000000800000000000
      result = vld1q_s32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 0);
         exp = UINT64_C(0x0000800000000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 1);
         exp = UINT64_C(0xffffffff2b858000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1189() {

{
   {
      int64_t arg1[2];
      int64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"load1\", fnname = \"vld1q_s64\", rettype = \"int64x2_t\", argtypes = \"[__transfersize(2) int64_t const *]\", vals = [PtrVal [IntegerVal (-7326230694764440498),IntegerVal (-9223090564025587838)]], start_saturated = False}";
      int reported = 0;
      arg1[0] = INT64_C(-7326230694764440498);
      arg1[1] = INT64_C(-9223090564025587838);
      clear_neon_saturated();
      //  Expect: "result" = 8000ffff7fff67829a53ffffc800944e
      result = vld1q_s64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 0);
         exp = UINT64_C(0x9a53ffffc800944e);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 1);
         exp = UINT64_C(0x8000ffff7fff6782);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1190() {

{
   {
      float32_t arg1[4];
      float32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"load1\", fnname = \"vld1q_f32\", rettype = \"float32x4_t\", argtypes = \"[__transfersize(4) float32_t const *]\", vals = [PtrVal [FloatVal 0.1814945936203003,FloatVal 0.8444065451622009,FloatVal 0.5111832022666931,FloatVal 0.9615277647972107]], start_saturated = False}";
      int reported = 0;
      arg1[0] = ((float32_t) 0.1814945936203003);
      arg1[1] = ((float32_t) 0.8444065451622009);
      arg1[2] = ((float32_t) 0.5111832022666931);
      arg1[3] = ((float32_t) 0.9615277647972107);
      clear_neon_saturated();
      //  Expect: "result" = 3f7626af3f02dce73f582b073e39d9b8
      result = vld1q_f32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 0);
         exp = ((float32_t) 0.1814945936203003);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 1);
         exp = ((float32_t) 0.8444065451622009);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 2);
         exp = ((float32_t) 0.5111832022666931);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 2 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 3);
         exp = ((float32_t) 0.9615277647972107);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 3 ", exp, got);
            }
      }
   }
}
}
void dotests_1191() {

{
   {
      float64_t arg1[2];
      float64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"load1\", fnname = \"vld1q_f64\", rettype = \"float64x2_t\", argtypes = \"[__transfersize(2) float64_t const *]\", vals = [PtrVal [FloatVal 0.6413440887488593,FloatVal 0.6921659995052785]], start_saturated = False}";
      int reported = 0;
      arg1[0] = 0.6413440887488593;
      arg1[1] = 0.6921659995052785;
      clear_neon_saturated();
      //  Expect: "result" = 3fe626394f68e8063fe485e409d518c2
      result = vld1q_f64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float64_t got;
         float64_t exp;
         got = vgetq_lane_f64(result, 0);
         exp = 0.6413440887488593;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float64_t got;
         float64_t exp;
         got = vgetq_lane_f64(result, 1);
         exp = 0.6921659995052785;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
   }
}
}
void dotests_1192() {

{
   {
      poly8_t arg1[16];
      poly8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"load1\", fnname = \"vld1q_p8\", rettype = \"poly8x16_t\", argtypes = \"[__transfersize(16) poly8_t const *]\", vals = [PtrVal [PolyVal [0,0,0,1,1,1,1,1],PolyVal [1,1,1,1,1,0,0,1],PolyVal [1,0,0,1,1,0,0,0],PolyVal [1,1,1,1,1,1,0,0],PolyVal [1,1,1,1,1,0,0,0],PolyVal [1,0,0,1,1,0,1,1],PolyVal [1,0,0,0,0,1,0,0],PolyVal [1,1,0,0,0,1,0,0],PolyVal [0,0,1,1,0,0,0,1],PolyVal [1,1,1,0,1,0,0,1],PolyVal [0,0,1,0,1,0,1,0],PolyVal [1,1,0,0,1,0,1,0],PolyVal [0,1,0,1,1,0,0,1],PolyVal [0,1,0,1,1,0,0,0],PolyVal [0,1,0,1,1,0,1,0],PolyVal [1,0,1,1,1,1,1,1]]], start_saturated = False}";
      int reported = 0;
      arg1[0] = 248;
      arg1[1] = 159;
      arg1[2] = 25;
      arg1[3] = 63;
      arg1[4] = 31;
      arg1[5] = 217;
      arg1[6] = 33;
      arg1[7] = 35;
      arg1[8] = 140;
      arg1[9] = 151;
      arg1[10] = 84;
      arg1[11] = 83;
      arg1[12] = 154;
      arg1[13] = 26;
      arg1[14] = 90;
      arg1[15] = 253;
      clear_neon_saturated();
      //  Expect: "result" = fd5a1a9a5354978c2321d91f3f199ff8
      result = vld1q_p8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p8(result), 0);
         exp = UINT64_C(0x2321d91f3f199ff8);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p8(result), 1);
         exp = UINT64_C(0xfd5a1a9a5354978c);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1193() {

{
   {
      poly16_t arg1[8];
      poly16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"load1\", fnname = \"vld1q_p16\", rettype = \"poly16x8_t\", argtypes = \"[__transfersize(8) poly16_t const *]\", vals = [PtrVal [PolyVal [0,0,0,0,0,0,1,0,1,1,1,1,0,1,0,0],PolyVal [1,1,0,0,1,0,0,1,1,1,1,0,1,1,0,0],PolyVal [1,1,1,1,0,0,0,1,1,0,0,0,0,0,1,1],PolyVal [0,1,0,1,1,1,0,0,1,0,1,1,0,1,0,1],PolyVal [0,1,1,1,0,0,1,0,1,1,0,0,1,0,0,1],PolyVal [0,1,0,0,1,1,1,1,1,1,1,0,0,0,0,0],PolyVal [1,1,1,0,0,1,1,1,0,1,1,1,1,0,1,1],PolyVal [1,0,0,1,1,1,0,1,0,0,0,1,1,0,0,0]]], start_saturated = False}";
      int reported = 0;
      arg1[0] = 12096;
      arg1[1] = 14227;
      arg1[2] = 49551;
      arg1[3] = 44346;
      arg1[4] = 37710;
      arg1[5] = 2034;
      arg1[6] = 57063;
      arg1[7] = 6329;
      clear_neon_saturated();
      //  Expect: "result" = 18b9dee707f2934ead3ac18f37932f40
      result = vld1q_p16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p16(result), 0);
         exp = UINT64_C(0xad3ac18f37932f40);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p16(result), 1);
         exp = UINT64_C(0x18b9dee707f2934e);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1194() {
#if __ARM_NEON_FP16_INTRINSICS

{
   {
      __fp16 arg1[8];
      float16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"load1\", fnname = \"vld1q_f16\", rettype = \"float16x8_t\", argtypes = \"[__transfersize(8) __fp16 const *]\", vals = [PtrVal [FloatVal 5.927558272845754,FloatVal 0.6576630723900969,FloatVal 3.118560319141066,FloatVal (-9.21634600186762),FloatVal 8.55554848504136,FloatVal (-8.950036963092014),FloatVal 3.918835755738419,FloatVal (-4.959043055301649)]], start_saturated = False}";
      int reported = 0;
      arg1[0] = 5.927558272845754;
      arg1[1] = 0.6576630723900969;
      arg1[2] = 3.118560319141066;
      arg1[3] = -9.21634600186762;
      arg1[4] = 8.55554848504136;
      arg1[5] = -8.950036963092014;
      arg1[6] = 3.918835755738419;
      arg1[7] = -4.959043055301649;
      clear_neon_saturated();
      //  Expect: "result" = c4f543d6c8794847c89b423c394245ed
      result = vld1q_f16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result, 0);
         exp = 5.927558272845754;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result, 1);
         exp = 0.6576630723900969;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result, 2);
         exp = 3.118560319141066;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 2 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result, 3);
         exp = -9.21634600186762;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 3 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result, 4);
         exp = 8.55554848504136;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 4 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result, 5);
         exp = -8.950036963092014;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 5 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result, 6);
         exp = 3.918835755738419;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 6 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result, 7);
         exp = -4.959043055301649;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 7 ", exp, got);
            }
      }
   }
}
#endif
}
void dotests_1195() {

{
   {
      poly64_t arg1[2];
      poly64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"load1\", fnname = \"vld1q_p64\", rettype = \"poly64x2_t\", argtypes = \"[__transfersize(2) poly64_t const *]\", vals = [PtrVal [PolyVal [1,0,0,0,0,0,0,1,1,0,0,0,0,0,1,1,0,1,0,0,0,1,0,1,0,1,0,0,0,0,0,0,1,0,0,0,1,1,1,1,1,1,1,0,0,0,1,1,0,0,0,1,0,0,0,0,0,1,1,1,1,1,0,1],PolyVal [1,0,0,0,0,0,1,1,1,1,0,1,0,0,0,0,1,1,1,0,1,1,1,0,1,1,0,0,0,1,1,0,0,0,0,1,0,1,0,0,1,0,0,1,0,1,1,0,1,1,1,1,0,0,1,0,1,0,1,1,1,1,0,1]]], start_saturated = False}";
      int reported = 0;
      arg1[0] = -4753329568744291967;
      arg1[1] = -4805506655192675391;
      clear_neon_saturated();
      //  Expect: "result" = bd4f692863770bc1be08c7f102a2c181
      result = vld1q_p64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p64(result), 0);
         exp = UINT64_C(0xbe08c7f102a2c181);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p64(result), 1);
         exp = UINT64_C(0xbd4f692863770bc1);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1196() {

{
   {
      uint8_t arg1[8];
      uint8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"load1\", fnname = \"vld1_u8\", rettype = \"uint8x8_t\", argtypes = \"[__transfersize(8) uint8_t const *]\", vals = [PtrVal [IntegerVal 46,IntegerVal 255,IntegerVal 128,IntegerVal 0,IntegerVal 112,IntegerVal 127,IntegerVal 245,IntegerVal 150]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1[0] = 46U;
      arg1[1] = 255U;
      arg1[2] = 128U;
      arg1[3] = 0;
      arg1[4] = 112U;
      arg1[5] = 127U;
      arg1[6] = 245U;
      arg1[7] = 150U;
      clear_neon_saturated();
      //  Expect: "result" = 96f57f700080ff2e
      result = vld1_u8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u8(result), 0);
      exp = UINT64_C(0x96f57f700080ff2e);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1197() {

{
   {
      uint16_t arg1[4];
      uint16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"load1\", fnname = \"vld1_u16\", rettype = \"uint16x4_t\", argtypes = \"[__transfersize(4) uint16_t const *]\", vals = [PtrVal [IntegerVal 0,IntegerVal 32767,IntegerVal 0,IntegerVal 0]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1[0] = 0;
      arg1[1] = 32767U;
      arg1[2] = 0;
      arg1[3] = 0;
      clear_neon_saturated();
      //  Expect: "result" = 000000007fff0000
      result = vld1_u16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u16(result), 0);
      exp = UINT64_C(0x000000007fff0000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1198() {

{
   {
      uint32_t arg1[2];
      uint32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"load1\", fnname = \"vld1_u32\", rettype = \"uint32x2_t\", argtypes = \"[__transfersize(2) uint32_t const *]\", vals = [PtrVal [IntegerVal 65535,IntegerVal 2147483648]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1[0] = 65535U;
      arg1[1] = 2147483648U;
      clear_neon_saturated();
      //  Expect: "result" = 800000000000ffff
      result = vld1_u32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u32(result), 0);
      exp = UINT64_C(0x800000000000ffff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1199() {

{
   {
      uint64_t arg1[1];
      uint64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"load1\", fnname = \"vld1_u64\", rettype = \"uint64x1_t\", argtypes = \"[__transfersize(1) uint64_t const *]\", vals = [PtrVal [IntegerVal 18446685251984944895]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1[0] = UINT64_C(0xffffca807fffeeff);
      clear_neon_saturated();
      //  Expect: "result" = ffffca807fffeeff
      result = vld1_u64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(result, 0);
      exp = UINT64_C(0xffffca807fffeeff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1200() {

{
   {
      int8_t arg1[8];
      int8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"load1\", fnname = \"vld1_s8\", rettype = \"int8x8_t\", argtypes = \"[__transfersize(8) int8_t const *]\", vals = [PtrVal [IntegerVal (-128),IntegerVal (-1),IntegerVal (-1),IntegerVal 127,IntegerVal (-78),IntegerVal (-128),IntegerVal 127,IntegerVal 0]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1[0] = -128;
      arg1[1] = -1;
      arg1[2] = -1;
      arg1[3] = 127;
      arg1[4] = -78;
      arg1[5] = -128;
      arg1[6] = 127;
      arg1[7] = 0;
      clear_neon_saturated();
      //  Expect: "result" = 007f80b27fffff80
      result = vld1_s8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s8(result), 0);
      exp = UINT64_C(0x007f80b27fffff80);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1201() {

{
   {
      int16_t arg1[4];
      int16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"load1\", fnname = \"vld1_s16\", rettype = \"int16x4_t\", argtypes = \"[__transfersize(4) int16_t const *]\", vals = [PtrVal [IntegerVal 32767,IntegerVal 0,IntegerVal 0,IntegerVal 0]], start_saturated = True}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1[0] = 32767;
      arg1[1] = 0;
      arg1[2] = 0;
      arg1[3] = 0;
      set_neon_saturated();
      //  Expect: "result" = 0000000000007fff
      result = vld1_s16(arg1);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s16(result), 0);
      exp = UINT64_C(0x0000000000007fff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1202() {

{
   {
      int32_t arg1[2];
      int32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"load1\", fnname = \"vld1_s32\", rettype = \"int32x2_t\", argtypes = \"[__transfersize(2) int32_t const *]\", vals = [PtrVal [IntegerVal 176062463,IntegerVal 824]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1[0] = 176062463;
      arg1[1] = 824;
      clear_neon_saturated();
      //  Expect: "result" = 000003380a7e7fff
      result = vld1_s32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s32(result), 0);
      exp = UINT64_C(0x000003380a7e7fff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1203() {

{
   {
      int64_t arg1[1];
      int64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"load1\", fnname = \"vld1_s64\", rettype = \"int64x1_t\", argtypes = \"[__transfersize(1) int64_t const *]\", vals = [PtrVal [IntegerVal 4294934527]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1[0] = INT64_C(4294934527);
      clear_neon_saturated();
      //  Expect: "result" = 00000000ffff7fff
      result = vld1_s64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s64(result), 0);
      exp = UINT64_C(0x00000000ffff7fff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1204() {

{
   {
      float32_t arg1[2];
      float32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"load1\", fnname = \"vld1_f32\", rettype = \"float32x2_t\", argtypes = \"[__transfersize(2) float32_t const *]\", vals = [PtrVal [FloatVal 0.6995062828063965,FloatVal 0.9203411340713501]], start_saturated = True}";
      int reported = 0;
      arg1[0] = ((float32_t) 0.6995062828063965);
      arg1[1] = ((float32_t) 0.9203411340713501);
      set_neon_saturated();
      //  Expect: "result" = 3f6b9b7a3f3312d8
      result = vld1_f32(arg1);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result, 0);
         exp = ((float32_t) 0.6995062828063965);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result, 1);
         exp = ((float32_t) 0.9203411340713501);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
   }
}
}
void dotests_1205() {

{
   {
      float64_t arg1[1];
      float64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"load1\", fnname = \"vld1_f64\", rettype = \"float64x1_t\", argtypes = \"[__transfersize(1) float64_t const *]\", vals = [PtrVal [FloatVal 0.1427674356538151]], start_saturated = False}";
      int reported = 0;
      float64_t got;
      float64_t exp;
      arg1[0] = 0.1427674356538151;
      clear_neon_saturated();
      //  Expect: "result" = 3fc246340d8890d8
      result = vld1_f64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_f64(result, 0);
      exp = 0.1427674356538151;
      if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
         }
   }
}
}
void dotests_1206() {

{
   {
      poly8_t arg1[8];
      poly8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"load1\", fnname = \"vld1_p8\", rettype = \"poly8x8_t\", argtypes = \"[__transfersize(8) poly8_t const *]\", vals = [PtrVal [PolyVal [1,1,0,0,1,1,0,0],PolyVal [0,1,0,1,1,1,1,0],PolyVal [1,1,1,1,0,1,1,1],PolyVal [1,1,0,1,0,0,0,0],PolyVal [1,0,1,1,1,1,0,1],PolyVal [1,0,1,1,1,1,0,1],PolyVal [1,1,0,0,0,1,1,0],PolyVal [1,1,1,0,1,1,1,1]]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1[0] = 51;
      arg1[1] = 122;
      arg1[2] = 239;
      arg1[3] = 11;
      arg1[4] = 189;
      arg1[5] = 189;
      arg1[6] = 99;
      arg1[7] = 247;
      clear_neon_saturated();
      //  Expect: "result" = f763bdbd0bef7a33
      result = vld1_p8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_p8(result), 0);
      exp = UINT64_C(0xf763bdbd0bef7a33);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1207() {

{
   {
      poly16_t arg1[4];
      poly16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"load1\", fnname = \"vld1_p16\", rettype = \"poly16x4_t\", argtypes = \"[__transfersize(4) poly16_t const *]\", vals = [PtrVal [PolyVal [1,1,1,1,1,0,0,1,1,1,1,1,0,0,1,0],PolyVal [0,0,0,1,0,1,1,1,0,1,0,1,1,0,0,1],PolyVal [0,0,1,0,0,0,1,0,0,1,1,1,0,1,1,1],PolyVal [1,1,1,0,1,0,1,0,0,1,0,1,1,1,1,0]]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1[0] = 20383;
      arg1[1] = 39656;
      arg1[2] = 60996;
      arg1[3] = 31319;
      clear_neon_saturated();
      //  Expect: "result" = 7a57ee449ae84f9f
      result = vld1_p16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_p16(result), 0);
      exp = UINT64_C(0x7a57ee449ae84f9f);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1208() {
#if __ARM_NEON_FP16_INTRINSICS

{
   {
      __fp16 arg1[4];
      float16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"load1\", fnname = \"vld1_f16\", rettype = \"float16x4_t\", argtypes = \"[__transfersize(4) __fp16 const *]\", vals = [PtrVal [FloatVal (-7.686385267545743),FloatVal (-3.620460646791946),FloatVal 8.396476554391064,FloatVal (-2.079308153601696)]], start_saturated = False}";
      int reported = 0;
      arg1[0] = -7.686385267545743;
      arg1[1] = -3.620460646791946;
      arg1[2] = 8.396476554391064;
      arg1[3] = -2.079308153601696;
      clear_neon_saturated();
      //  Expect: "result" = c0284832c33dc7af
      result = vld1_f16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         __fp16 got;
         __fp16 exp;
         got = vget_lane_f16(result, 0);
         exp = -7.686385267545743;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vget_lane_f16(result, 1);
         exp = -3.620460646791946;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vget_lane_f16(result, 2);
         exp = 8.396476554391064;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 2 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vget_lane_f16(result, 3);
         exp = -2.079308153601696;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 3 ", exp, got);
            }
      }
   }
}
#endif
}
void dotests_1209() {

{
   {
      poly64_t arg1[1];
      poly64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"load1\", fnname = \"vld1_p64\", rettype = \"poly64x1_t\", argtypes = \"[__transfersize(1) poly64_t const *]\", vals = [PtrVal [PolyVal [0,1,0,0,1,1,0,0,1,0,0,0,0,1,1,1,0,0,1,0,1,1,0,0,0,1,0,0,1,1,0,0,1,0,0,1,1,1,1,0,1,1,0,1,1,0,1,0,0,0,0,0,1,0,0,0,1,1,0,1,0,0,0,1]]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1[0] = -8426134326718701262;
      clear_neon_saturated();
      //  Expect: "result" = 8b105b793234e132
      result = vld1_p64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_p64(result), 0);
      exp = UINT64_C(0x8b105b793234e132);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1210() {

{
   {
      uint8_t arg1[1];
      uint8x16_t arg2;
      uint8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"load1_lane\", fnname = \"vld1q_lane_u8\", rettype = \"uint8x16_t\", argtypes = \"[__transfersize(1) uint8_t const *,uint8x16_t,__constrange(0,15) int]\", vals = [PtrVal [IntegerVal 69],VectorVal [IntegerVal 255,IntegerVal 127,IntegerVal 209,IntegerVal 127,IntegerVal 0,IntegerVal 0,IntegerVal 127,IntegerVal 127,IntegerVal 255,IntegerVal 128,IntegerVal 255,IntegerVal 127,IntegerVal 255,IntegerVal 128,IntegerVal 255,IntegerVal 255],IndexVal 6], start_saturated = False}";
      int reported = 0;
      arg1[0] = 69U;
      arg2 = vcombine_u8(vcreate_u8(UINT64_C(0x7f7f00007fd17fff)),
                         vcreate_u8(UINT64_C(0xffff80ff7fff80ff)));
      clear_neon_saturated();
      //  Expect: "result" = ffff80ff7fff80ff7f4500007fd17fff
      result = vld1q_lane_u8(arg1, arg2, 6);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 0);
         exp = UINT64_C(0x7f4500007fd17fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 1);
         exp = UINT64_C(0xffff80ff7fff80ff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1211() {

{
   {
      uint16_t arg1[1];
      uint16x8_t arg2;
      uint16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"load1_lane\", fnname = \"vld1q_lane_u16\", rettype = \"uint16x8_t\", argtypes = \"[__transfersize(1) uint16_t const *,uint16x8_t,__constrange(0,7) int]\", vals = [PtrVal [IntegerVal 32767],VectorVal [IntegerVal 0,IntegerVal 32768,IntegerVal 32768,IntegerVal 15631,IntegerVal 65535,IntegerVal 0,IntegerVal 16037,IntegerVal 65535],IndexVal 1], start_saturated = False}";
      int reported = 0;
      arg1[0] = 32767U;
      arg2 = vcombine_u16(vcreate_u16(UINT64_C(0x3d0f800080000000)),
                          vcreate_u16(UINT64_C(0xffff3ea50000ffff)));
      clear_neon_saturated();
      //  Expect: "result" = ffff3ea50000ffff3d0f80007fff0000
      result = vld1q_lane_u16(arg1, arg2, 1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 0);
         exp = UINT64_C(0x3d0f80007fff0000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 1);
         exp = UINT64_C(0xffff3ea50000ffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1212() {

{
   {
      uint32_t arg1[1];
      uint32x4_t arg2;
      uint32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"load1_lane\", fnname = \"vld1q_lane_u32\", rettype = \"uint32x4_t\", argtypes = \"[__transfersize(1) uint32_t const *,uint32x4_t,__constrange(0,3) int]\", vals = [PtrVal [IntegerVal 927799318],VectorVal [IntegerVal 2712436736,IntegerVal 1137278975,IntegerVal 2147549183,IntegerVal 2147483647],IndexVal 3], start_saturated = False}";
      int reported = 0;
      arg1[0] = 927799318U;
      arg2 = vcombine_u32(vcreate_u32(UINT64_C(0x43c97fffa1ac8000)),
                          vcreate_u32(UINT64_C(0x7fffffff8000ffff)));
      clear_neon_saturated();
      //  Expect: "result" = 374d18168000ffff43c97fffa1ac8000
      result = vld1q_lane_u32(arg1, arg2, 3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 0);
         exp = UINT64_C(0x43c97fffa1ac8000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 1);
         exp = UINT64_C(0x374d18168000ffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1213() {

{
   {
      uint64_t arg1[1];
      uint64x2_t arg2;
      uint64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"load1_lane\", fnname = \"vld1q_lane_u64\", rettype = \"uint64x2_t\", argtypes = \"[__transfersize(1) uint64_t const *,uint64x2_t,__constrange(0,1) int]\", vals = [PtrVal [IntegerVal 18446744071562002432],VectorVal [IntegerVal 9292192666512982016,IntegerVal 4294967295],IndexVal 1], start_saturated = False}";
      int reported = 0;
      arg1[0] = UINT64_C(0xffffffff7fff0000);
      arg2 = vcombine_u64(vcreate_u64(UINT64_C(0x80f47fff7fff0000)),
                          vcreate_u64(UINT64_C(0x00000000ffffffff)));
      clear_neon_saturated();
      //  Expect: "result" = ffffffff7fff000080f47fff7fff0000
      result = vld1q_lane_u64(arg1, arg2, 1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 0);
         exp = UINT64_C(0x80f47fff7fff0000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 1);
         exp = UINT64_C(0xffffffff7fff0000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1214() {

{
   {
      int8_t arg1[1];
      int8x16_t arg2;
      int8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"load1_lane\", fnname = \"vld1q_lane_s8\", rettype = \"int8x16_t\", argtypes = \"[__transfersize(1) int8_t const *,int8x16_t,__constrange(0,15) int]\", vals = [PtrVal [IntegerVal (-128)],VectorVal [IntegerVal 127,IntegerVal 127,IntegerVal (-32),IntegerVal 0,IntegerVal (-1),IntegerVal 0,IntegerVal 127,IntegerVal 127,IntegerVal (-128),IntegerVal 24,IntegerVal (-128),IntegerVal (-1),IntegerVal (-128),IntegerVal (-1),IntegerVal (-1),IntegerVal 69],IndexVal 15], start_saturated = False}";
      int reported = 0;
      arg1[0] = -128;
      arg2 = vcombine_s8(vcreate_s8(UINT64_C(0x7f7f00ff00e07f7f)),
                         vcreate_s8(UINT64_C(0x45ffff80ff801880)));
      clear_neon_saturated();
      //  Expect: "result" = 80ffff80ff8018807f7f00ff00e07f7f
      result = vld1q_lane_s8(arg1, arg2, 15);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result), 0);
         exp = UINT64_C(0x7f7f00ff00e07f7f);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result), 1);
         exp = UINT64_C(0x80ffff80ff801880);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1215() {

{
   {
      int16_t arg1[1];
      int16x8_t arg2;
      int16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"load1_lane\", fnname = \"vld1q_lane_s16\", rettype = \"int16x8_t\", argtypes = \"[__transfersize(1) int16_t const *,int16x8_t,__constrange(0,7) int]\", vals = [PtrVal [IntegerVal (-32768)],VectorVal [IntegerVal 18528,IntegerVal 32767,IntegerVal 0,IntegerVal 0,IntegerVal 32767,IntegerVal (-1),IntegerVal 32767,IntegerVal 0],IndexVal 3], start_saturated = False}";
      int reported = 0;
      arg1[0] = -32768;
      arg2 = vcombine_s16(vcreate_s16(UINT64_C(0x000000007fff4860)),
                          vcreate_s16(UINT64_C(0x00007fffffff7fff)));
      clear_neon_saturated();
      //  Expect: "result" = 00007fffffff7fff800000007fff4860
      result = vld1q_lane_s16(arg1, arg2, 3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 0);
         exp = UINT64_C(0x800000007fff4860);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 1);
         exp = UINT64_C(0x00007fffffff7fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1216() {

{
   {
      int32_t arg1[1];
      int32x4_t arg2;
      int32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"load1_lane\", fnname = \"vld1q_lane_s32\", rettype = \"int32x4_t\", argtypes = \"[__transfersize(1) int32_t const *,int32x4_t,__constrange(0,3) int]\", vals = [PtrVal [IntegerVal 65535],VectorVal [IntegerVal (-32769),IntegerVal 32768,IntegerVal (-2147450881),IntegerVal (-2147483648)],IndexVal 0], start_saturated = False}";
      int reported = 0;
      arg1[0] = 65535;
      arg2 = vcombine_s32(vcreate_s32(UINT64_C(0x00008000ffff7fff)),
                          vcreate_s32(UINT64_C(0x8000000080007fff)));
      clear_neon_saturated();
      //  Expect: "result" = 8000000080007fff000080000000ffff
      result = vld1q_lane_s32(arg1, arg2, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 0);
         exp = UINT64_C(0x000080000000ffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 1);
         exp = UINT64_C(0x8000000080007fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1217() {

{
   {
      float32_t arg1[1];
      float32x4_t arg2;
      float32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"load1_lane\", fnname = \"vld1q_lane_f32\", rettype = \"float32x4_t\", argtypes = \"[__transfersize(1) float32_t const *,float32x4_t,__constrange(0,3) int]\", vals = [PtrVal [FloatVal 0.9216150045394897],VectorVal [FloatVal 0.29266810417175293,FloatVal 0.7208579778671265,FloatVal 0.8552693128585815,FloatVal 0.282879114151001],IndexVal 1], start_saturated = False}";
      int reported = 0;
      arg1[0] = ((float32_t) 0.9216150045394897);
      arg2 = vcombine_f32(vcreate_f32(UINT64_C(0x3f388a263e95d898)),
                          vcreate_f32(UINT64_C(0x3e90d5883f5af2ee)));
      clear_neon_saturated();
      //  Expect: "result" = 3e90d5883f5af2ee3f6beef63e95d898
      result = vld1q_lane_f32(arg1, arg2, 1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 0);
         exp = ((float32_t) 0.29266810417175293);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 1);
         exp = ((float32_t) 0.9216150045394897);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 2);
         exp = ((float32_t) 0.8552693128585815);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 2 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 3);
         exp = ((float32_t) 0.282879114151001);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 3 ", exp, got);
            }
      }
   }
}
}
void dotests_1218() {

{
   {
      float64_t arg1[1];
      float64x2_t arg2;
      float64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"load1_lane\", fnname = \"vld1q_lane_f64\", rettype = \"float64x2_t\", argtypes = \"[__transfersize(1) float64_t const *,float64x2_t,__constrange(0,1) int]\", vals = [PtrVal [FloatVal 0.7850496511889392],VectorVal [FloatVal 0.4439517930065314,FloatVal 0.6398596699432413],IndexVal 1], start_saturated = False}";
      int reported = 0;
      arg1[0] = 0.7850496511889392;
      arg2 = vcombine_f64(vcreate_f64(UINT64_C(0x3fdc69b4c7fdabda)),
                          vcreate_f64(UINT64_C(0x3fe479bafc8df03c)));
      clear_neon_saturated();
      //  Expect: "result" = 3fe91f207232f7693fdc69b4c7fdabda
      result = vld1q_lane_f64(arg1, arg2, 1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float64_t got;
         float64_t exp;
         got = vgetq_lane_f64(result, 0);
         exp = 0.4439517930065314;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float64_t got;
         float64_t exp;
         got = vgetq_lane_f64(result, 1);
         exp = 0.7850496511889392;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
   }
}
}
void dotests_1219() {

{
   {
      int64_t arg1[1];
      int64x2_t arg2;
      int64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"load1_lane\", fnname = \"vld1q_lane_s64\", rettype = \"int64x2_t\", argtypes = \"[__transfersize(1) int64_t const *,int64x2_t,__constrange(0,1) int]\", vals = [PtrVal [IntegerVal (-140741345240494)],VectorVal [IntegerVal (-1396397356579717121),IntegerVal 9223372034707279028],IndexVal 1], start_saturated = False}";
      int reported = 0;
      arg1[0] = INT64_C(-140741345240494);
      arg2 = vcombine_s64(vcreate_s64(UINT64_C(0xec9f0000abc57fff)),
                          vcreate_s64(UINT64_C(0x7fffffff7fffccb4)));
      clear_neon_saturated();
      //  Expect: "result" = ffff7fff1a1c9a52ec9f0000abc57fff
      result = vld1q_lane_s64(arg1, arg2, 1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 0);
         exp = UINT64_C(0xec9f0000abc57fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 1);
         exp = UINT64_C(0xffff7fff1a1c9a52);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1220() {

{
   {
      poly8_t arg1[1];
      poly8x16_t arg2;
      poly8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"load1_lane\", fnname = \"vld1q_lane_p8\", rettype = \"poly8x16_t\", argtypes = \"[__transfersize(1) poly8_t const *,poly8x16_t,__constrange(0,15) int]\", vals = [PtrVal [PolyVal [1,0,1,0,0,1,1,1]],VectorVal [PolyVal [1,1,0,0,1,1,1,0],PolyVal [1,0,0,0,0,1,1,1],PolyVal [0,1,0,0,0,1,1,1],PolyVal [1,1,0,0,1,0,0,1],PolyVal [1,0,0,1,1,1,0,1],PolyVal [0,0,0,1,1,0,0,1],PolyVal [0,0,1,0,1,0,0,1],PolyVal [0,0,0,1,1,1,1,1],PolyVal [1,0,0,1,1,1,0,0],PolyVal [0,1,1,1,1,0,0,1],PolyVal [1,1,0,1,0,0,0,1],PolyVal [1,1,1,1,0,1,1,0],PolyVal [0,0,0,1,0,1,1,0],PolyVal [1,0,0,0,0,0,0,1],PolyVal [1,0,1,1,0,1,1,0],PolyVal [1,1,0,0,1,0,1,1]],IndexVal 5], start_saturated = True}";
      int reported = 0;
      arg1[0] = 229;
      arg2 = vcombine_p8(vcreate_p8(UINT64_C(0xf89498b993e2e173)),
                         vcreate_p8(UINT64_C(0xd36d81686f8b9e39)));
      set_neon_saturated();
      //  Expect: "result" = d36d81686f8b9e39f894e5b993e2e173
      result = vld1q_lane_p8(arg1, arg2, 5);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p8(result), 0);
         exp = UINT64_C(0xf894e5b993e2e173);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p8(result), 1);
         exp = UINT64_C(0xd36d81686f8b9e39);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1221() {

{
   {
      poly16_t arg1[1];
      poly16x8_t arg2;
      poly16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"load1_lane\", fnname = \"vld1q_lane_p16\", rettype = \"poly16x8_t\", argtypes = \"[__transfersize(1) poly16_t const *,poly16x8_t,__constrange(0,7) int]\", vals = [PtrVal [PolyVal [0,0,1,0,1,1,1,1,0,1,1,1,1,1,1,0]],VectorVal [PolyVal [0,1,0,0,1,1,0,1,0,0,0,0,0,1,0,1],PolyVal [1,1,0,1,1,0,0,1,1,0,1,1,0,1,1,1],PolyVal [0,1,0,1,0,1,0,0,0,0,1,0,1,0,0,1],PolyVal [0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0],PolyVal [1,0,0,0,1,0,0,1,1,0,1,0,0,1,0,1],PolyVal [0,1,0,1,0,1,0,1,0,0,1,0,0,0,1,1],PolyVal [0,0,1,1,0,1,1,0,1,1,0,1,0,0,1,1],PolyVal [0,0,0,0,1,0,0,0,1,1,0,0,0,0,1,1]],IndexVal 1], start_saturated = False}";
      int reported = 0;
      arg1[0] = 32500;
      arg2 = vcombine_p16(vcreate_p16(UINT64_C(0x4808942aed9ba0b2)),
                          vcreate_p16(UINT64_C(0xc310cb6cc4aaa591)));
      clear_neon_saturated();
      //  Expect: "result" = c310cb6cc4aaa5914808942a7ef4a0b2
      result = vld1q_lane_p16(arg1, arg2, 1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p16(result), 0);
         exp = UINT64_C(0x4808942a7ef4a0b2);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p16(result), 1);
         exp = UINT64_C(0xc310cb6cc4aaa591);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1222() {
#if __ARM_NEON_FP16_INTRINSICS

{
   {
      __fp16 arg1[1];
      float16x8_t arg2;
      float16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"load1_lane\", fnname = \"vld1q_lane_f16\", rettype = \"float16x8_t\", argtypes = \"[__transfersize(1) __fp16 const *,float16x8_t,__constrange(0,7) int]\", vals = [PtrVal [FloatVal (-9.906000180970217)],VectorVal [FloatVal 5.78786087018387,FloatVal (-3.598579271611431),FloatVal 0.9930759891357752,FloatVal (-8.056589437938896),FloatVal (-3.7090370276748867),FloatVal (-0.342324870459338),FloatVal 4.695838450906436,FloatVal 8.081915679544792],IndexVal 2], start_saturated = False}";
      int reported = 0;
      arg1[0] = -9.906000180970217;
      arg2 = vcombine_f16(vcreate_f16(UINT64_C(0xc8073bf1c33245c9)),
                          vcreate_f16(UINT64_C(0x480a44b2b57ac36b)));
      clear_neon_saturated();
      //  Expect: "result" = 480a44b2b57ac36bc807c8f3c33245c9
      result = vld1q_lane_f16(arg1, arg2, 2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result, 0);
         exp = 5.78786087018387;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result, 1);
         exp = -3.598579271611431;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result, 2);
         exp = -9.906000180970217;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 2 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result, 3);
         exp = -8.056589437938896;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 3 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result, 4);
         exp = -3.7090370276748867;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 4 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result, 5);
         exp = -0.342324870459338;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 5 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result, 6);
         exp = 4.695838450906436;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 6 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result, 7);
         exp = 8.081915679544792;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 7 ", exp, got);
            }
      }
   }
}
#endif
}
void dotests_1223() {

{
   {
      poly64_t arg1[1];
      poly64x2_t arg2;
      poly64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"load1_lane\", fnname = \"vld1q_lane_p64\", rettype = \"poly64x2_t\", argtypes = \"[__transfersize(1) poly64_t const *,poly64x2_t,__constrange(0,1) int]\", vals = [PtrVal [PolyVal [1,1,1,0,1,1,1,0,0,1,0,1,1,1,1,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,0,0,1,1,0,0,1,0,0,0,0,1,1,0,0,1,0,0,0,1,0,1,1,0,0,1,1,1,1,1,1,1,0]],VectorVal [PolyVal [1,0,0,0,0,0,1,0,1,1,0,0,1,1,0,1,1,1,0,0,1,1,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,1,0,0,1,1,0,0,1,0,0,1,1,0,1,0,1,1,1,1,1,1,1,1,1,1,0],PolyVal [1,1,1,0,0,1,1,1,1,0,0,0,1,0,0,0,1,0,1,1,0,0,1,1,0,1,1,0,0,1,0,0,0,0,1,0,1,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,1,1,0,0,1]],IndexVal 1], start_saturated = False}";
      int reported = 0;
      arg1[0] = 9166034869829007991;
      arg2 = vcombine_p64(vcreate_p64(UINT64_C(0x7feb26418073b341)),
                          vcreate_p64(UINT64_C(0x9a24031426cd11e7)));
      clear_neon_saturated();
      //  Expect: "result" = 7f344c267f007a777feb26418073b341
      result = vld1q_lane_p64(arg1, arg2, 1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p64(result), 0);
         exp = UINT64_C(0x7feb26418073b341);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p64(result), 1);
         exp = UINT64_C(0x7f344c267f007a77);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1224() {

{
   {
      uint8_t arg1[1];
      uint8x8_t arg2;
      uint8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"load1_lane\", fnname = \"vld1_lane_u8\", rettype = \"uint8x8_t\", argtypes = \"[__transfersize(1) uint8_t const *,uint8x8_t,__constrange(0,7) int]\", vals = [PtrVal [IntegerVal 0],VectorVal [IntegerVal 128,IntegerVal 0,IntegerVal 127,IntegerVal 127,IntegerVal 128,IntegerVal 215,IntegerVal 127,IntegerVal 255],IndexVal 0], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1[0] = 0;
      arg2 = vcreate_u8(UINT64_C(0xff7fd7807f7f0080));
      clear_neon_saturated();
      //  Expect: "result" = ff7fd7807f7f0000
      result = vld1_lane_u8(arg1, arg2, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u8(result), 0);
      exp = UINT64_C(0xff7fd7807f7f0000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1225() {

{
   {
      uint16_t arg1[1];
      uint16x4_t arg2;
      uint16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"load1_lane\", fnname = \"vld1_lane_u16\", rettype = \"uint16x4_t\", argtypes = \"[__transfersize(1) uint16_t const *,uint16x4_t,__constrange(0,3) int]\", vals = [PtrVal [IntegerVal 22861],VectorVal [IntegerVal 41736,IntegerVal 0,IntegerVal 32768,IntegerVal 32768],IndexVal 3], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1[0] = 22861U;
      arg2 = vcreate_u16(UINT64_C(0x800080000000a308));
      clear_neon_saturated();
      //  Expect: "result" = 594d80000000a308
      result = vld1_lane_u16(arg1, arg2, 3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u16(result), 0);
      exp = UINT64_C(0x594d80000000a308);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1226() {

{
   {
      uint32_t arg1[1];
      uint32x2_t arg2;
      uint32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"load1_lane\", fnname = \"vld1_lane_u32\", rettype = \"uint32x2_t\", argtypes = \"[__transfersize(1) uint32_t const *,uint32x2_t,__constrange(0,1) int]\", vals = [PtrVal [IntegerVal 2147483647],VectorVal [IntegerVal 2147483648,IntegerVal 4294967295],IndexVal 1], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1[0] = 2147483647U;
      arg2 = vcreate_u32(UINT64_C(0xffffffff80000000));
      clear_neon_saturated();
      //  Expect: "result" = 7fffffff80000000
      result = vld1_lane_u32(arg1, arg2, 1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u32(result), 0);
      exp = UINT64_C(0x7fffffff80000000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1227() {

{
   {
      uint64_t arg1[1];
      uint64x1_t arg2;
      uint64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"load1_lane\", fnname = \"vld1_lane_u64\", rettype = \"uint64x1_t\", argtypes = \"[__transfersize(1) uint64_t const *,uint64x1_t,__constrange(0,0) int]\", vals = [PtrVal [IntegerVal 9223601892767072255],VectorVal [IntegerVal 18446744071467765142],IndexVal 0], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1[0] = UINT64_C(0x8000d10d80007fff);
      arg2 = vcreate_u64(UINT64_C(0xffffffff7a610d96));
      clear_neon_saturated();
      //  Expect: "result" = 8000d10d80007fff
      result = vld1_lane_u64(arg1, arg2, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(result, 0);
      exp = UINT64_C(0x8000d10d80007fff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1228() {

{
   {
      int8_t arg1[1];
      int8x8_t arg2;
      int8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"load1_lane\", fnname = \"vld1_lane_s8\", rettype = \"int8x8_t\", argtypes = \"[__transfersize(1) int8_t const *,int8x8_t,__constrange(0,7) int]\", vals = [PtrVal [IntegerVal 127],VectorVal [IntegerVal 0,IntegerVal 127,IntegerVal 127,IntegerVal 127,IntegerVal (-1),IntegerVal (-1),IntegerVal (-128),IntegerVal 127],IndexVal 5], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1[0] = 127;
      arg2 = vcreate_s8(UINT64_C(0x7f80ffff7f7f7f00));
      clear_neon_saturated();
      //  Expect: "result" = 7f807fff7f7f7f00
      result = vld1_lane_s8(arg1, arg2, 5);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s8(result), 0);
      exp = UINT64_C(0x7f807fff7f7f7f00);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1229() {

{
   {
      int16_t arg1[1];
      int16x4_t arg2;
      int16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"load1_lane\", fnname = \"vld1_lane_s16\", rettype = \"int16x4_t\", argtypes = \"[__transfersize(1) int16_t const *,int16x4_t,__constrange(0,3) int]\", vals = [PtrVal [IntegerVal (-32768)],VectorVal [IntegerVal 0,IntegerVal (-1),IntegerVal (-1),IntegerVal 30676],IndexVal 2], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1[0] = -32768;
      arg2 = vcreate_s16(UINT64_C(0x77d4ffffffff0000));
      clear_neon_saturated();
      //  Expect: "result" = 77d48000ffff0000
      result = vld1_lane_s16(arg1, arg2, 2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s16(result), 0);
      exp = UINT64_C(0x77d48000ffff0000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1230() {

{
   {
      int32_t arg1[1];
      int32x2_t arg2;
      int32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"load1_lane\", fnname = \"vld1_lane_s32\", rettype = \"int32x2_t\", argtypes = \"[__transfersize(1) int32_t const *,int32x2_t,__constrange(0,1) int]\", vals = [PtrVal [IntegerVal 2147450880],VectorVal [IntegerVal 1007583232,IntegerVal 869924863],IndexVal 0], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1[0] = 2147450880;
      arg2 = vcreate_s32(UINT64_C(0x33d9ffff3c0e8000));
      clear_neon_saturated();
      //  Expect: "result" = 33d9ffff7fff8000
      result = vld1_lane_s32(arg1, arg2, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s32(result), 0);
      exp = UINT64_C(0x33d9ffff7fff8000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1231() {

{
   {
      float32_t arg1[1];
      float32x2_t arg2;
      float32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"load1_lane\", fnname = \"vld1_lane_f32\", rettype = \"float32x2_t\", argtypes = \"[__transfersize(1) float32_t const *,float32x2_t,__constrange(0,1) int]\", vals = [PtrVal [FloatVal 0.5073444843292236],VectorVal [FloatVal 0.6937801837921143,FloatVal 0.26690179109573364],IndexVal 1], start_saturated = False}";
      int reported = 0;
      arg1[0] = ((float32_t) 0.5073444843292236);
      arg2 = vcreate_f32(UINT64_C(0x3e88a75a3f319b94));
      clear_neon_saturated();
      //  Expect: "result" = 3f01e1543f319b94
      result = vld1_lane_f32(arg1, arg2, 1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result, 0);
         exp = ((float32_t) 0.6937801837921143);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result, 1);
         exp = ((float32_t) 0.5073444843292236);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
   }
}
}
void dotests_1232() {

{
   {
      float64_t arg1[1];
      float64x1_t arg2;
      float64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"load1_lane\", fnname = \"vld1_lane_f64\", rettype = \"float64x1_t\", argtypes = \"[__transfersize(1) float64_t const *,float64x1_t,__constrange(0,0) int]\", vals = [PtrVal [FloatVal 0.4425242464519019],VectorVal [FloatVal 0.7866808283308943],IndexVal 0], start_saturated = False}";
      int reported = 0;
      float64_t got;
      float64_t exp;
      arg1[0] = 0.4425242464519019;
      arg2 = vcreate_f64(UINT64_C(0x3fe92c7d45c248c1));
      clear_neon_saturated();
      //  Expect: "result" = 3fdc5251378cab6c
      result = vld1_lane_f64(arg1, arg2, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_f64(result, 0);
      exp = 0.4425242464519019;
      if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
         }
   }
}
}
void dotests_1233() {

{
   {
      int64_t arg1[1];
      int64x1_t arg2;
      int64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"load1_lane\", fnname = \"vld1_lane_s64\", rettype = \"int64x1_t\", argtypes = \"[__transfersize(1) int64_t const *,int64x1_t,__constrange(0,0) int]\", vals = [PtrVal [IntegerVal 281470681808895],VectorVal [IntegerVal (-9223372032559808513)],IndexVal 0], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1[0] = INT64_C(281470681808895);
      arg2 = vcreate_s64(UINT64_C(0x80000000ffffffff));
      clear_neon_saturated();
      //  Expect: "result" = 0000ffff0000ffff
      result = vld1_lane_s64(arg1, arg2, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s64(result), 0);
      exp = UINT64_C(0x0000ffff0000ffff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1234() {

{
   {
      poly8_t arg1[1];
      poly8x8_t arg2;
      poly8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"load1_lane\", fnname = \"vld1_lane_p8\", rettype = \"poly8x8_t\", argtypes = \"[__transfersize(1) poly8_t const *,poly8x8_t,__constrange(0,7) int]\", vals = [PtrVal [PolyVal [0,1,0,1,0,1,0,0]],VectorVal [PolyVal [0,0,1,0,0,1,1,0],PolyVal [0,1,0,1,0,0,1,0],PolyVal [0,0,0,0,0,1,1,0],PolyVal [0,1,1,1,0,0,0,1],PolyVal [1,1,0,1,1,1,1,0],PolyVal [0,1,0,0,0,0,1,0],PolyVal [0,1,0,0,1,0,1,1],PolyVal [1,1,1,0,1,0,1,1]],IndexVal 7], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1[0] = 42;
      arg2 = vcreate_p8(UINT64_C(0xd7d2427b8e604a64));
      clear_neon_saturated();
      //  Expect: "result" = 2ad2427b8e604a64
      result = vld1_lane_p8(arg1, arg2, 7);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_p8(result), 0);
      exp = UINT64_C(0x2ad2427b8e604a64);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1235() {

{
   {
      poly16_t arg1[1];
      poly16x4_t arg2;
      poly16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"load1_lane\", fnname = \"vld1_lane_p16\", rettype = \"poly16x4_t\", argtypes = \"[__transfersize(1) poly16_t const *,poly16x4_t,__constrange(0,3) int]\", vals = [PtrVal [PolyVal [1,0,0,0,0,0,1,1,1,1,0,1,0,0,0,0]],VectorVal [PolyVal [0,1,1,0,0,0,1,0,0,1,0,1,0,0,0,1],PolyVal [0,1,1,0,0,1,1,0,0,0,0,0,1,1,0,1],PolyVal [0,1,0,0,0,0,1,1,0,1,1,1,1,1,1,0],PolyVal [0,0,0,1,1,0,1,1,1,0,0,1,1,1,1,0]],IndexVal 0], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1[0] = 3009;
      arg2 = vcreate_p16(UINT64_C(0x79d87ec2b0668a46));
      clear_neon_saturated();
      //  Expect: "result" = 79d87ec2b0660bc1
      result = vld1_lane_p16(arg1, arg2, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_p16(result), 0);
      exp = UINT64_C(0x79d87ec2b0660bc1);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1236() {
#if __ARM_NEON_FP16_INTRINSICS

{
   {
      __fp16 arg1[1];
      float16x4_t arg2;
      float16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"load1_lane\", fnname = \"vld1_lane_f16\", rettype = \"float16x4_t\", argtypes = \"[__transfersize(1) __fp16 const *,float16x4_t,__constrange(0,3) int]\", vals = [PtrVal [FloatVal 5.317508025949952],VectorVal [FloatVal (-0.192736565578965),FloatVal (-5.1056758359098975),FloatVal (-6.373106520796066),FloatVal 4.292570311294222],IndexVal 2], start_saturated = False}";
      int reported = 0;
      arg1[0] = 5.317508025949952;
      arg2 = vcreate_f16(UINT64_C(0x444ac65fc51bb22a));
      clear_neon_saturated();
      //  Expect: "result" = 444a4551c51bb22a
      result = vld1_lane_f16(arg1, arg2, 2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         __fp16 got;
         __fp16 exp;
         got = vget_lane_f16(result, 0);
         exp = -0.192736565578965;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vget_lane_f16(result, 1);
         exp = -5.1056758359098975;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vget_lane_f16(result, 2);
         exp = 5.317508025949952;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 2 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vget_lane_f16(result, 3);
         exp = 4.292570311294222;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 3 ", exp, got);
            }
      }
   }
}
#endif
}
void dotests_1237() {

{
   {
      poly64_t arg1[1];
      poly64x1_t arg2;
      poly64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"load1_lane\", fnname = \"vld1_lane_p64\", rettype = \"poly64x1_t\", argtypes = \"[__transfersize(1) poly64_t const *,poly64x1_t,__constrange(0,0) int]\", vals = [PtrVal [PolyVal [0,1,0,0,1,0,0,1,0,1,1,1,0,1,0,1,0,0,0,1,0,1,0,0,1,1,0,1,1,1,1,1,1,1,0,0,0,0,1,0,1,1,1,1,0,1,0,1,0,0,1,0,1,1,1,0,0,1,1,1,1,0,0,0]],VectorVal [PolyVal [0,0,1,0,0,0,1,1,1,0,0,1,1,0,0,0,0,1,0,1,0,0,0,1,1,0,1,1,1,1,1,0,0,0,1,0,1,1,1,1,1,0,0,0,1,1,1,0,0,1,1,1,0,0,0,0,0,1,0,0,0,1,1,0]],IndexVal 0], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1[0] = 2194571624947691154;
      arg2 = vcreate_p64(UINT64_C(0x620e71f47d8a19c4));
      clear_neon_saturated();
      //  Expect: "result" = 1e74af43fb28ae92
      result = vld1_lane_p64(arg1, arg2, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_p64(result), 0);
      exp = UINT64_C(0x1e74af43fb28ae92);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1238() {

{
   {
      uint8_t arg1[1];
      uint8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"load1_alllanes\", fnname = \"vld1q_dup_u8\", rettype = \"uint8x16_t\", argtypes = \"[__transfersize(1) uint8_t const *]\", vals = [PtrVal [IntegerVal 255]], start_saturated = False}";
      int reported = 0;
      arg1[0] = 255U;
      clear_neon_saturated();
      //  Expect: "result" = ffffffffffffffffffffffffffffffff
      result = vld1q_dup_u8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 0);
         exp = UINT64_C(0xffffffffffffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 1);
         exp = UINT64_C(0xffffffffffffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1239() {

{
   {
      uint16_t arg1[1];
      uint16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"load1_alllanes\", fnname = \"vld1q_dup_u16\", rettype = \"uint16x8_t\", argtypes = \"[__transfersize(1) uint16_t const *]\", vals = [PtrVal [IntegerVal 32767]], start_saturated = False}";
      int reported = 0;
      arg1[0] = 32767U;
      clear_neon_saturated();
      //  Expect: "result" = 7fff7fff7fff7fff7fff7fff7fff7fff
      result = vld1q_dup_u16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 0);
         exp = UINT64_C(0x7fff7fff7fff7fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 1);
         exp = UINT64_C(0x7fff7fff7fff7fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1240() {

{
   {
      uint32_t arg1[1];
      uint32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"load1_alllanes\", fnname = \"vld1q_dup_u32\", rettype = \"uint32x4_t\", argtypes = \"[__transfersize(1) uint32_t const *]\", vals = [PtrVal [IntegerVal 1669332991]], start_saturated = False}";
      int reported = 0;
      arg1[0] = 1669332991U;
      clear_neon_saturated();
      //  Expect: "result" = 637fffff637fffff637fffff637fffff
      result = vld1q_dup_u32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 0);
         exp = UINT64_C(0x637fffff637fffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 1);
         exp = UINT64_C(0x637fffff637fffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1241() {

{
   {
      uint64_t arg1[1];
      uint64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"load1_alllanes\", fnname = \"vld1q_dup_u64\", rettype = \"uint64x2_t\", argtypes = \"[__transfersize(1) uint64_t const *]\", vals = [PtrVal [IntegerVal 415248641599523741]], start_saturated = False}";
      int reported = 0;
      arg1[0] = UINT64_C(0x05c342708000cb9d);
      clear_neon_saturated();
      //  Expect: "result" = 05c342708000cb9d05c342708000cb9d
      result = vld1q_dup_u64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 0);
         exp = UINT64_C(0x05c342708000cb9d);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 1);
         exp = UINT64_C(0x05c342708000cb9d);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1242() {

{
   {
      int8_t arg1[1];
      int8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"load1_alllanes\", fnname = \"vld1q_dup_s8\", rettype = \"int8x16_t\", argtypes = \"[__transfersize(1) int8_t const *]\", vals = [PtrVal [IntegerVal 0]], start_saturated = False}";
      int reported = 0;
      arg1[0] = 0;
      clear_neon_saturated();
      //  Expect: "result" = 00000000000000000000000000000000
      result = vld1q_dup_s8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result), 0);
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result), 1);
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1243() {

{
   {
      int16_t arg1[1];
      int16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"load1_alllanes\", fnname = \"vld1q_dup_s16\", rettype = \"int16x8_t\", argtypes = \"[__transfersize(1) int16_t const *]\", vals = [PtrVal [IntegerVal 0]], start_saturated = False}";
      int reported = 0;
      arg1[0] = 0;
      clear_neon_saturated();
      //  Expect: "result" = 00000000000000000000000000000000
      result = vld1q_dup_s16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 0);
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 1);
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1244() {

{
   {
      int32_t arg1[1];
      int32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"load1_alllanes\", fnname = \"vld1q_dup_s32\", rettype = \"int32x4_t\", argtypes = \"[__transfersize(1) int32_t const *]\", vals = [PtrVal [IntegerVal 458719232]], start_saturated = False}";
      int reported = 0;
      arg1[0] = 458719232;
      clear_neon_saturated();
      //  Expect: "result" = 1b5780001b5780001b5780001b578000
      result = vld1q_dup_s32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 0);
         exp = UINT64_C(0x1b5780001b578000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 1);
         exp = UINT64_C(0x1b5780001b578000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1245() {

{
   {
      int64_t arg1[1];
      int64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"load1_alllanes\", fnname = \"vld1q_dup_s64\", rettype = \"int64x2_t\", argtypes = \"[__transfersize(1) int64_t const *]\", vals = [PtrVal [IntegerVal 6211461224794619904]], start_saturated = False}";
      int reported = 0;
      arg1[0] = INT64_C(6211461224794619904);
      clear_neon_saturated();
      //  Expect: "result" = 56338b12ffff000056338b12ffff0000
      result = vld1q_dup_s64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 0);
         exp = UINT64_C(0x56338b12ffff0000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 1);
         exp = UINT64_C(0x56338b12ffff0000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1246() {

{
   {
      float32_t arg1[1];
      float32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"load1_alllanes\", fnname = \"vld1q_dup_f32\", rettype = \"float32x4_t\", argtypes = \"[__transfersize(1) float32_t const *]\", vals = [PtrVal [FloatVal 0.20177406072616577]], start_saturated = False}";
      int reported = 0;
      arg1[0] = ((float32_t) 0.20177406072616577);
      clear_neon_saturated();
      //  Expect: "result" = 3e4e9ddc3e4e9ddc3e4e9ddc3e4e9ddc
      result = vld1q_dup_f32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 0);
         exp = ((float32_t) 0.20177406072616577);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 1);
         exp = ((float32_t) 0.20177406072616577);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 2);
         exp = ((float32_t) 0.20177406072616577);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 2 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 3);
         exp = ((float32_t) 0.20177406072616577);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 3 ", exp, got);
            }
      }
   }
}
}
void dotests_1247() {

{
   {
      float64_t arg1[1];
      float64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"load1_alllanes\", fnname = \"vld1q_dup_f64\", rettype = \"float64x2_t\", argtypes = \"[__transfersize(1) float64_t const *]\", vals = [PtrVal [FloatVal 0.41153808900620714]], start_saturated = False}";
      int reported = 0;
      arg1[0] = 0.41153808900620714;
      clear_neon_saturated();
      //  Expect: "result" = 3fda56a3da55c2823fda56a3da55c282
      result = vld1q_dup_f64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float64_t got;
         float64_t exp;
         got = vgetq_lane_f64(result, 0);
         exp = 0.41153808900620714;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float64_t got;
         float64_t exp;
         got = vgetq_lane_f64(result, 1);
         exp = 0.41153808900620714;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
   }
}
}
void dotests_1248() {

{
   {
      poly8_t arg1[1];
      poly8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"load1_alllanes\", fnname = \"vld1q_dup_p8\", rettype = \"poly8x16_t\", argtypes = \"[__transfersize(1) poly8_t const *]\", vals = [PtrVal [PolyVal [1,0,0,1,0,0,0,1]]], start_saturated = False}";
      int reported = 0;
      arg1[0] = 137;
      clear_neon_saturated();
      //  Expect: "result" = 89898989898989898989898989898989
      result = vld1q_dup_p8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p8(result), 0);
         exp = UINT64_C(0x8989898989898989);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p8(result), 1);
         exp = UINT64_C(0x8989898989898989);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1249() {

{
   {
      poly16_t arg1[1];
      poly16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"load1_alllanes\", fnname = \"vld1q_dup_p16\", rettype = \"poly16x8_t\", argtypes = \"[__transfersize(1) poly16_t const *]\", vals = [PtrVal [PolyVal [0,0,0,0,0,1,0,0,1,1,1,1,1,0,0,0]]], start_saturated = False}";
      int reported = 0;
      arg1[0] = 7968;
      clear_neon_saturated();
      //  Expect: "result" = 1f201f201f201f201f201f201f201f20
      result = vld1q_dup_p16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p16(result), 0);
         exp = UINT64_C(0x1f201f201f201f20);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p16(result), 1);
         exp = UINT64_C(0x1f201f201f201f20);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1250() {
#if __ARM_NEON_FP16_INTRINSICS

{
   {
      __fp16 arg1[1];
      float16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"load1_alllanes\", fnname = \"vld1q_dup_f16\", rettype = \"float16x8_t\", argtypes = \"[__transfersize(1) __fp16 const *]\", vals = [PtrVal [FloatVal (-2.9943760279516134)]], start_saturated = False}";
      int reported = 0;
      arg1[0] = -2.9943760279516134;
      clear_neon_saturated();
      //  Expect: "result" = c1fdc1fdc1fdc1fdc1fdc1fdc1fdc1fd
      result = vld1q_dup_f16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result, 0);
         exp = -2.9943760279516134;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result, 1);
         exp = -2.9943760279516134;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result, 2);
         exp = -2.9943760279516134;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 2 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result, 3);
         exp = -2.9943760279516134;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 3 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result, 4);
         exp = -2.9943760279516134;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 4 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result, 5);
         exp = -2.9943760279516134;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 5 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result, 6);
         exp = -2.9943760279516134;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 6 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result, 7);
         exp = -2.9943760279516134;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 7 ", exp, got);
            }
      }
   }
}
#endif
}
void dotests_1251() {

{
   {
      poly64_t arg1[1];
      poly64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"load1_alllanes\", fnname = \"vld1q_dup_p64\", rettype = \"poly64x2_t\", argtypes = \"[__transfersize(1) poly64_t const *]\", vals = [PtrVal [PolyVal [1,0,1,0,1,0,1,1,1,0,1,0,1,1,0,1,1,1,1,1,0,0,0,1,1,0,0,0,0,1,0,1,1,0,0,0,1,1,1,1,0,1,0,0,1,1,0,1,1,0,1,1,1,1,0,0,1,1,1,1,0,0,0,1]]], start_saturated = False}";
      int reported = 0;
      arg1[0] = -8125141401839094315;
      clear_neon_saturated();
      //  Expect: "result" = 8f3db2f1a18fb5d58f3db2f1a18fb5d5
      result = vld1q_dup_p64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p64(result), 0);
         exp = UINT64_C(0x8f3db2f1a18fb5d5);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p64(result), 1);
         exp = UINT64_C(0x8f3db2f1a18fb5d5);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1252() {

{
   {
      uint8_t arg1[1];
      uint8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"load1_alllanes\", fnname = \"vld1_dup_u8\", rettype = \"uint8x8_t\", argtypes = \"[__transfersize(1) uint8_t const *]\", vals = [PtrVal [IntegerVal 127]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1[0] = 127U;
      clear_neon_saturated();
      //  Expect: "result" = 7f7f7f7f7f7f7f7f
      result = vld1_dup_u8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u8(result), 0);
      exp = UINT64_C(0x7f7f7f7f7f7f7f7f);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1253() {

{
   {
      uint16_t arg1[1];
      uint16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"load1_alllanes\", fnname = \"vld1_dup_u16\", rettype = \"uint16x4_t\", argtypes = \"[__transfersize(1) uint16_t const *]\", vals = [PtrVal [IntegerVal 0]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1[0] = 0;
      clear_neon_saturated();
      //  Expect: "result" = 0000000000000000
      result = vld1_dup_u16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u16(result), 0);
      exp = 0;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1254() {

{
   {
      uint32_t arg1[1];
      uint32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"load1_alllanes\", fnname = \"vld1_dup_u32\", rettype = \"uint32x2_t\", argtypes = \"[__transfersize(1) uint32_t const *]\", vals = [PtrVal [IntegerVal 2147458535]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1[0] = 2147458535U;
      clear_neon_saturated();
      //  Expect: "result" = 7fff9de77fff9de7
      result = vld1_dup_u32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u32(result), 0);
      exp = UINT64_C(0x7fff9de77fff9de7);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1255() {

{
   {
      uint64_t arg1[1];
      uint64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"load1_alllanes\", fnname = \"vld1_dup_u64\", rettype = \"uint64x1_t\", argtypes = \"[__transfersize(1) uint64_t const *]\", vals = [PtrVal [IntegerVal 83552146325504]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1[0] = UINT64_C(0x00004bfd80008000);
      clear_neon_saturated();
      //  Expect: "result" = 00004bfd80008000
      result = vld1_dup_u64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(result, 0);
      exp = UINT64_C(0x00004bfd80008000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1256() {

{
   {
      int8_t arg1[1];
      int8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"load1_alllanes\", fnname = \"vld1_dup_s8\", rettype = \"int8x8_t\", argtypes = \"[__transfersize(1) int8_t const *]\", vals = [PtrVal [IntegerVal (-128)]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1[0] = -128;
      clear_neon_saturated();
      //  Expect: "result" = 8080808080808080
      result = vld1_dup_s8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s8(result), 0);
      exp = UINT64_C(0x8080808080808080);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1257() {

{
   {
      int16_t arg1[1];
      int16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"load1_alllanes\", fnname = \"vld1_dup_s16\", rettype = \"int16x4_t\", argtypes = \"[__transfersize(1) int16_t const *]\", vals = [PtrVal [IntegerVal (-1)]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1[0] = -1;
      clear_neon_saturated();
      //  Expect: "result" = ffffffffffffffff
      result = vld1_dup_s16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s16(result), 0);
      exp = UINT64_C(0xffffffffffffffff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1258() {

{
   {
      int32_t arg1[1];
      int32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"load1_alllanes\", fnname = \"vld1_dup_s32\", rettype = \"int32x2_t\", argtypes = \"[__transfersize(1) int32_t const *]\", vals = [PtrVal [IntegerVal (-2147450880)]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1[0] = -2147450880;
      clear_neon_saturated();
      //  Expect: "result" = 8000800080008000
      result = vld1_dup_s32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s32(result), 0);
      exp = UINT64_C(0x8000800080008000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1259() {

{
   {
      int64_t arg1[1];
      int64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"load1_alllanes\", fnname = \"vld1_dup_s64\", rettype = \"int64x1_t\", argtypes = \"[__transfersize(1) int64_t const *]\", vals = [PtrVal [IntegerVal 379191296]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1[0] = INT64_C(379191296);
      clear_neon_saturated();
      //  Expect: "result" = 00000000169a0000
      result = vld1_dup_s64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s64(result), 0);
      exp = UINT64_C(0x00000000169a0000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1260() {

{
   {
      float32_t arg1[1];
      float32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"load1_alllanes\", fnname = \"vld1_dup_f32\", rettype = \"float32x2_t\", argtypes = \"[__transfersize(1) float32_t const *]\", vals = [PtrVal [FloatVal 7.665592432022095e-2]], start_saturated = False}";
      int reported = 0;
      arg1[0] = ((float32_t) 7.665592432022095e-2);
      clear_neon_saturated();
      //  Expect: "result" = 3d9cfdc83d9cfdc8
      result = vld1_dup_f32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result, 0);
         exp = ((float32_t) 7.665592432022095e-2);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result, 1);
         exp = ((float32_t) 7.665592432022095e-2);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
   }
}
}
void dotests_1261() {

{
   {
      float64_t arg1[1];
      float64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"load1_alllanes\", fnname = \"vld1_dup_f64\", rettype = \"float64x1_t\", argtypes = \"[__transfersize(1) float64_t const *]\", vals = [PtrVal [FloatVal 0.5384004402646557]], start_saturated = False}";
      int reported = 0;
      float64_t got;
      float64_t exp;
      arg1[0] = 0.5384004402646557;
      clear_neon_saturated();
      //  Expect: "result" = 3fe13a938f62d69d
      result = vld1_dup_f64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_f64(result, 0);
      exp = 0.5384004402646557;
      if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
         }
   }
}
}
void dotests_1262() {

{
   {
      poly8_t arg1[1];
      poly8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"load1_alllanes\", fnname = \"vld1_dup_p8\", rettype = \"poly8x8_t\", argtypes = \"[__transfersize(1) poly8_t const *]\", vals = [PtrVal [PolyVal [0,0,1,0,0,0,1,0]]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1[0] = 68;
      clear_neon_saturated();
      //  Expect: "result" = 4444444444444444
      result = vld1_dup_p8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_p8(result), 0);
      exp = UINT64_C(0x4444444444444444);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1263() {

{
   {
      poly16_t arg1[1];
      poly16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"load1_alllanes\", fnname = \"vld1_dup_p16\", rettype = \"poly16x4_t\", argtypes = \"[__transfersize(1) poly16_t const *]\", vals = [PtrVal [PolyVal [1,1,1,1,0,0,0,1,1,0,0,1,1,0,1,1]]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1[0] = 55695;
      clear_neon_saturated();
      //  Expect: "result" = d98fd98fd98fd98f
      result = vld1_dup_p16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_p16(result), 0);
      exp = UINT64_C(0xd98fd98fd98fd98f);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1264() {
#if __ARM_NEON_FP16_INTRINSICS

{
   {
      __fp16 arg1[1];
      float16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"load1_alllanes\", fnname = \"vld1_dup_f16\", rettype = \"float16x4_t\", argtypes = \"[__transfersize(1) __fp16 const *]\", vals = [PtrVal [FloatVal (-6.62709213535379)]], start_saturated = False}";
      int reported = 0;
      arg1[0] = -6.62709213535379;
      clear_neon_saturated();
      //  Expect: "result" = c6a0c6a0c6a0c6a0
      result = vld1_dup_f16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         __fp16 got;
         __fp16 exp;
         got = vget_lane_f16(result, 0);
         exp = -6.62709213535379;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vget_lane_f16(result, 1);
         exp = -6.62709213535379;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vget_lane_f16(result, 2);
         exp = -6.62709213535379;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 2 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vget_lane_f16(result, 3);
         exp = -6.62709213535379;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 3 ", exp, got);
            }
      }
   }
}
#endif
}
void dotests_1265() {

{
   {
      poly64_t arg1[1];
      poly64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"load1_alllanes\", fnname = \"vld1_dup_p64\", rettype = \"poly64x1_t\", argtypes = \"[__transfersize(1) poly64_t const *]\", vals = [PtrVal [PolyVal [1,0,0,1,1,0,1,0,1,0,0,1,0,1,1,0,0,1,1,1,1,0,1,0,0,0,1,0,0,1,1,1,1,1,1,0,1,1,1,0,1,0,0,1,1,1,0,1,0,0,0,0,1,1,0,1,1,1,0,1,1,0,0,0]]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1[0] = 1995298559508769113;
      clear_neon_saturated();
      //  Expect: "result" = 1bb0b977e45e6959
      result = vld1_dup_p64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_p64(result), 0);
      exp = UINT64_C(0x1bb0b977e45e6959);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1266() {

{
   {
      uint8x16_t arg2;
      uint8_t result[16];
      char* str1 = "ReproInfo2 {semantics = \"store1\", fnname = \"vst1q_u8\", rettype = \"__transfersize(16) uint8_t *\", argtypes = \"[/* result holder */,uint8x16_t]\", vals = [PtrVal [],VectorVal [IntegerVal 120,IntegerVal 106,IntegerVal 0,IntegerVal 127,IntegerVal 128,IntegerVal 0,IntegerVal 128,IntegerVal 128,IntegerVal 255,IntegerVal 255,IntegerVal 127,IntegerVal 78,IntegerVal 255,IntegerVal 255,IntegerVal 255,IntegerVal 0]], start_saturated = False}";
      int reported = 0;
      arg2 = vcombine_u8(vcreate_u8(UINT64_C(0x808000807f006a78)),
                         vcreate_u8(UINT64_C(0x00ffffff4e7fffff)));
      clear_neon_saturated();
      vst1q_u8(result, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint8_t got;
         uint8_t exp;
         got = result[0];
         exp = 120U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 0 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[1];
         exp = 106U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 1 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[2];
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 2 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[3];
         exp = 127U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 3 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[4];
         exp = 128U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 4 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[5];
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 5 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[6];
         exp = 128U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 6 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[7];
         exp = 128U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 7 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[8];
         exp = 255U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 8 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[9];
         exp = 255U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 9 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[10];
         exp = 127U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 10 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[11];
         exp = 78U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 11 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[12];
         exp = 255U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 12 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[13];
         exp = 255U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 13 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[14];
         exp = 255U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 14 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[15];
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 15 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1267() {

{
   {
      uint16x8_t arg2;
      uint16_t result[8];
      char* str1 = "ReproInfo2 {semantics = \"store1\", fnname = \"vst1q_u16\", rettype = \"__transfersize(8) uint16_t *\", argtypes = \"[/* result holder */,uint16x8_t]\", vals = [PtrVal [],VectorVal [IntegerVal 65535,IntegerVal 46918,IntegerVal 32768,IntegerVal 65535,IntegerVal 65535,IntegerVal 54408,IntegerVal 0,IntegerVal 48088]], start_saturated = False}";
      int reported = 0;
      arg2 = vcombine_u16(vcreate_u16(UINT64_C(0xffff8000b746ffff)),
                          vcreate_u16(UINT64_C(0xbbd80000d488ffff)));
      clear_neon_saturated();
      vst1q_u16(result, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint16_t got;
         uint16_t exp;
         got = result[0];
         exp = 65535U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 0 ",
                      exp,
                      got);
            }
      }
      {
         uint16_t got;
         uint16_t exp;
         got = result[1];
         exp = 46918U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 1 ",
                      exp,
                      got);
            }
      }
      {
         uint16_t got;
         uint16_t exp;
         got = result[2];
         exp = 32768U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 2 ",
                      exp,
                      got);
            }
      }
      {
         uint16_t got;
         uint16_t exp;
         got = result[3];
         exp = 65535U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 3 ",
                      exp,
                      got);
            }
      }
      {
         uint16_t got;
         uint16_t exp;
         got = result[4];
         exp = 65535U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 4 ",
                      exp,
                      got);
            }
      }
      {
         uint16_t got;
         uint16_t exp;
         got = result[5];
         exp = 54408U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 5 ",
                      exp,
                      got);
            }
      }
      {
         uint16_t got;
         uint16_t exp;
         got = result[6];
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 6 ",
                      exp,
                      got);
            }
      }
      {
         uint16_t got;
         uint16_t exp;
         got = result[7];
         exp = 48088U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 7 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1268() {

{
   {
      uint32x4_t arg2;
      uint32_t result[4];
      char* str1 = "ReproInfo2 {semantics = \"store1\", fnname = \"vst1q_u32\", rettype = \"__transfersize(4) uint32_t *\", argtypes = \"[/* result holder */,uint32x4_t]\", vals = [PtrVal [],VectorVal [IntegerVal 912818176,IntegerVal 4197416959,IntegerVal 1337982976,IntegerVal 0]], start_saturated = False}";
      int reported = 0;
      arg2 = vcombine_u32(vcreate_u32(UINT64_C(0xfa2f7fff36688000)),
                          vcreate_u32(UINT64_C(0x000000004fc00000)));
      clear_neon_saturated();
      vst1q_u32(result, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint32_t got;
         uint32_t exp;
         got = result[0];
         exp = 912818176U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu32 " Got: %" PRIu32 "\n",
                      "   Elem 0 ",
                      exp,
                      got);
            }
      }
      {
         uint32_t got;
         uint32_t exp;
         got = result[1];
         exp = 4197416959U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu32 " Got: %" PRIu32 "\n",
                      "   Elem 1 ",
                      exp,
                      got);
            }
      }
      {
         uint32_t got;
         uint32_t exp;
         got = result[2];
         exp = 1337982976U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu32 " Got: %" PRIu32 "\n",
                      "   Elem 2 ",
                      exp,
                      got);
            }
      }
      {
         uint32_t got;
         uint32_t exp;
         got = result[3];
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu32 " Got: %" PRIu32 "\n",
                      "   Elem 3 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1269() {

{
   {
      uint64x2_t arg2;
      uint64_t result[2];
      char* str1 = "ReproInfo2 {semantics = \"store1\", fnname = \"vst1q_u64\", rettype = \"__transfersize(2) uint64_t *\", argtypes = \"[/* result holder */,uint64x2_t]\", vals = [PtrVal [],VectorVal [IntegerVal 9223512778638065663,IntegerVal 9223094416611213311]], start_saturated = False}";
      int reported = 0;
      arg2 = vcombine_u64(vcreate_u64(UINT64_C(0x80008000ffff7fff)),
                          vcreate_u64(UINT64_C(0x7fff03817fffffff)));
      clear_neon_saturated();
      vst1q_u64(result, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = result[0];
         exp = UINT64_C(0x80008000ffff7fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Elem 0 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = result[1];
         exp = UINT64_C(0x7fff03817fffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Elem 1 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1270() {

{
   {
      int8x16_t arg2;
      int8_t result[16];
      char* str1 = "ReproInfo2 {semantics = \"store1\", fnname = \"vst1q_s8\", rettype = \"__transfersize(16) int8_t *\", argtypes = \"[/* result holder */,int8x16_t]\", vals = [PtrVal [],VectorVal [IntegerVal 0,IntegerVal 0,IntegerVal 0,IntegerVal (-95),IntegerVal 127,IntegerVal (-128),IntegerVal 127,IntegerVal 127,IntegerVal (-128),IntegerVal (-1),IntegerVal 2,IntegerVal (-1),IntegerVal (-35),IntegerVal 127,IntegerVal (-110),IntegerVal 64]], start_saturated = False}";
      int reported = 0;
      arg2 = vcombine_s8(vcreate_s8(UINT64_C(0x7f7f807fa1000000)),
                         vcreate_s8(UINT64_C(0x40927fddff02ff80)));
      clear_neon_saturated();
      vst1q_s8(result, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         int8_t got;
         int8_t exp;
         got = result[0];
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 0 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[1];
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 1 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[2];
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 2 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[3];
         exp = -95;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 3 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[4];
         exp = 127;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 4 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[5];
         exp = -128;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 5 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[6];
         exp = 127;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 6 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[7];
         exp = 127;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 7 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[8];
         exp = -128;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 8 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[9];
         exp = -1;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 9 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[10];
         exp = 2;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 10 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[11];
         exp = -1;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 11 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[12];
         exp = -35;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 12 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[13];
         exp = 127;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 13 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[14];
         exp = -110;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 14 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[15];
         exp = 64;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 15 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1271() {

{
   {
      int16x8_t arg2;
      int16_t result[8];
      char* str1 = "ReproInfo2 {semantics = \"store1\", fnname = \"vst1q_s16\", rettype = \"__transfersize(8) int16_t *\", argtypes = \"[/* result holder */,int16x8_t]\", vals = [PtrVal [],VectorVal [IntegerVal (-1),IntegerVal (-32768),IntegerVal 32767,IntegerVal 1785,IntegerVal 0,IntegerVal 23570,IntegerVal (-6793),IntegerVal 0]], start_saturated = True}";
      int reported = 0;
      arg2 = vcombine_s16(vcreate_s16(UINT64_C(0x06f97fff8000ffff)),
                          vcreate_s16(UINT64_C(0x0000e5775c120000)));
      set_neon_saturated();
      vst1q_s16(result, arg2);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      {
         int16_t got;
         int16_t exp;
         got = result[0];
         exp = -1;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi16 " Got: %" PRIi16 "\n",
                      "   Elem 0 ",
                      exp,
                      got);
            }
      }
      {
         int16_t got;
         int16_t exp;
         got = result[1];
         exp = -32768;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi16 " Got: %" PRIi16 "\n",
                      "   Elem 1 ",
                      exp,
                      got);
            }
      }
      {
         int16_t got;
         int16_t exp;
         got = result[2];
         exp = 32767;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi16 " Got: %" PRIi16 "\n",
                      "   Elem 2 ",
                      exp,
                      got);
            }
      }
      {
         int16_t got;
         int16_t exp;
         got = result[3];
         exp = 1785;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi16 " Got: %" PRIi16 "\n",
                      "   Elem 3 ",
                      exp,
                      got);
            }
      }
      {
         int16_t got;
         int16_t exp;
         got = result[4];
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi16 " Got: %" PRIi16 "\n",
                      "   Elem 4 ",
                      exp,
                      got);
            }
      }
      {
         int16_t got;
         int16_t exp;
         got = result[5];
         exp = 23570;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi16 " Got: %" PRIi16 "\n",
                      "   Elem 5 ",
                      exp,
                      got);
            }
      }
      {
         int16_t got;
         int16_t exp;
         got = result[6];
         exp = -6793;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi16 " Got: %" PRIi16 "\n",
                      "   Elem 6 ",
                      exp,
                      got);
            }
      }
      {
         int16_t got;
         int16_t exp;
         got = result[7];
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi16 " Got: %" PRIi16 "\n",
                      "   Elem 7 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1272() {

{
   {
      int32x4_t arg2;
      int32_t result[4];
      char* str1 = "ReproInfo2 {semantics = \"store1\", fnname = \"vst1q_s32\", rettype = \"__transfersize(4) int32_t *\", argtypes = \"[/* result holder */,int32x4_t]\", vals = [PtrVal [],VectorVal [IntegerVal 65535,IntegerVal 2147464067,IntegerVal (-65536),IntegerVal 2147418112]], start_saturated = False}";
      int reported = 0;
      arg2 = vcombine_s32(vcreate_s32(UINT64_C(0x7fffb3830000ffff)),
                          vcreate_s32(UINT64_C(0x7fff0000ffff0000)));
      clear_neon_saturated();
      vst1q_s32(result, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         int32_t got;
         int32_t exp;
         got = result[0];
         exp = 65535;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi32 " Got: %" PRIi32 "\n",
                      "   Elem 0 ",
                      exp,
                      got);
            }
      }
      {
         int32_t got;
         int32_t exp;
         got = result[1];
         exp = 2147464067;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi32 " Got: %" PRIi32 "\n",
                      "   Elem 1 ",
                      exp,
                      got);
            }
      }
      {
         int32_t got;
         int32_t exp;
         got = result[2];
         exp = -65536;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi32 " Got: %" PRIi32 "\n",
                      "   Elem 2 ",
                      exp,
                      got);
            }
      }
      {
         int32_t got;
         int32_t exp;
         got = result[3];
         exp = 2147418112;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi32 " Got: %" PRIi32 "\n",
                      "   Elem 3 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1273() {

{
   {
      int64x2_t arg2;
      int64_t result[2];
      char* str1 = "ReproInfo2 {semantics = \"store1\", fnname = \"vst1q_s64\", rettype = \"__transfersize(2) int64_t *\", argtypes = \"[/* result holder */,int64x2_t]\", vals = [PtrVal [],VectorVal [IntegerVal (-6688126919474479104),IntegerVal 6582433067867111423]], start_saturated = False}";
      int reported = 0;
      arg2 = vcombine_s64(vcreate_s64(UINT64_C(0xa32f00007fff0000)),
                          vcreate_s64(UINT64_C(0x5b5980000000ffff)));
      clear_neon_saturated();
      vst1q_s64(result, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         int64_t got;
         int64_t exp;
         got = result[0];
         exp = INT64_C(-6688126919474479104);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi64 " Got: %" PRIi64 "\n",
                      "   Elem 0 ",
                      exp,
                      got);
            }
      }
      {
         int64_t got;
         int64_t exp;
         got = result[1];
         exp = INT64_C(6582433067867111423);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi64 " Got: %" PRIi64 "\n",
                      "   Elem 1 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1274() {

{
   {
      float32x4_t arg2;
      float32_t result[4];
      char* str1 = "ReproInfo2 {semantics = \"store1\", fnname = \"vst1q_f32\", rettype = \"__transfersize(4) float32_t *\", argtypes = \"[/* result holder */,float32x4_t]\", vals = [PtrVal [],VectorVal [FloatVal 0.802828848361969,FloatVal 0.7681431174278259,FloatVal 0.3806173801422119,FloatVal 0.5862451195716858]], start_saturated = False}";
      int reported = 0;
      arg2 = vcombine_f32(vcreate_f32(UINT64_C(0x3f44a5073f4d8631)),
                          vcreate_f32(UINT64_C(0x3f1614293ec2e048)));
      clear_neon_saturated();
      vst1q_f32(result, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = result[0];
         exp = ((float32_t) 0.802828848361969);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 0 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = result[1];
         exp = ((float32_t) 0.7681431174278259);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 1 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = result[2];
         exp = ((float32_t) 0.3806173801422119);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 2 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = result[3];
         exp = ((float32_t) 0.5862451195716858);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 3 ", exp, got);
            }
      }
   }
}
}
void dotests_1275() {

{
   {
      float64x2_t arg2;
      float64_t result[2];
      char* str1 = "ReproInfo2 {semantics = \"store1\", fnname = \"vst1q_f64\", rettype = \"__transfersize(2) float64_t *\", argtypes = \"[/* result holder */,float64x2_t]\", vals = [PtrVal [],VectorVal [FloatVal 7.34439620417634e-2,FloatVal 0.7038445944708455]], start_saturated = False}";
      int reported = 0;
      arg2 = vcombine_f64(vcreate_f64(UINT64_C(0x3fb2cd39370edba8)),
                          vcreate_f64(UINT64_C(0x3fe685e51956ff4b)));
      clear_neon_saturated();
      vst1q_f64(result, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float64_t got;
         float64_t exp;
         got = result[0];
         exp = 7.34439620417634e-2;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 0 ", exp, got);
            }
      }
      {
         float64_t got;
         float64_t exp;
         got = result[1];
         exp = 0.7038445944708455;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 1 ", exp, got);
            }
      }
   }
}
}
void dotests_1276() {

{
   {
      poly8x16_t arg2;
      poly8_t result[16];
      char* str1 = "ReproInfo2 {semantics = \"store1\", fnname = \"vst1q_p8\", rettype = \"__transfersize(16) poly8_t *\", argtypes = \"[/* result holder */,poly8x16_t]\", vals = [PtrVal [],VectorVal [PolyVal [1,0,0,0,0,1,0,1],PolyVal [1,0,1,0,0,0,0,1],PolyVal [1,1,1,0,1,0,0,1],PolyVal [1,0,1,1,1,1,1,0],PolyVal [0,1,0,1,1,0,0,0],PolyVal [1,1,0,1,0,0,1,1],PolyVal [1,0,0,1,0,1,1,1],PolyVal [0,1,1,1,1,0,0,0],PolyVal [1,0,0,1,1,0,0,1],PolyVal [0,0,0,1,0,0,0,1],PolyVal [0,0,1,0,1,1,1,1],PolyVal [0,0,0,0,1,0,1,0],PolyVal [0,1,0,1,0,1,1,0],PolyVal [1,0,1,0,0,0,1,0],PolyVal [0,1,0,1,1,0,0,0],PolyVal [1,1,0,1,1,0,0,1]]], start_saturated = True}";
      int reported = 0;
      arg2 = vcombine_p8(vcreate_p8(UINT64_C(0x1ee9cb1a7d9785a1)),
                         vcreate_p8(UINT64_C(0x9b1a456a50f48899)));
      set_neon_saturated();
      vst1q_p8(result, arg2);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      {
         poly8_t got;
         poly8_t exp;
         got = result[0];
         exp = 161;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 0 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[1];
         exp = 133;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 1 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[2];
         exp = 151;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 2 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[3];
         exp = 125;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 3 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[4];
         exp = 26;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 4 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[5];
         exp = 203;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 5 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[6];
         exp = 233;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 6 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[7];
         exp = 30;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 7 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[8];
         exp = 153;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 8 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[9];
         exp = 136;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 9 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[10];
         exp = 244;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 10 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[11];
         exp = 80;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 11 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[12];
         exp = 106;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 12 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[13];
         exp = 69;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 13 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[14];
         exp = 26;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 14 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[15];
         exp = 155;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 15 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1277() {

{
   {
      poly16x8_t arg2;
      poly16_t result[8];
      char* str1 = "ReproInfo2 {semantics = \"store1\", fnname = \"vst1q_p16\", rettype = \"__transfersize(8) poly16_t *\", argtypes = \"[/* result holder */,poly16x8_t]\", vals = [PtrVal [],VectorVal [PolyVal [0,1,0,0,0,1,0,0,0,0,1,1,1,0,1,1],PolyVal [1,1,0,1,0,1,1,0,1,0,0,0,1,1,0,1],PolyVal [0,0,0,0,0,1,1,0,1,0,0,0,0,1,1,0],PolyVal [1,0,1,0,1,0,1,1,1,1,0,1,0,1,0,1],PolyVal [1,0,1,0,1,1,1,1,1,1,1,0,0,1,1,0],PolyVal [0,0,0,1,1,0,1,1,0,0,0,0,1,0,1,0],PolyVal [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1],PolyVal [0,1,1,0,0,1,0,0,0,0,1,1,0,0,1,1]]], start_saturated = False}";
      int reported = 0;
      arg2 = vcombine_p16(vcreate_p16(UINT64_C(0xabd56160b16bdc22)),
                          vcreate_p16(UINT64_C(0xcc26804050d867f5)));
      clear_neon_saturated();
      vst1q_p16(result, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         poly16_t got;
         poly16_t exp;
         got = result[0];
         exp = 56354;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 0 ",
                      exp,
                      got);
            }
      }
      {
         poly16_t got;
         poly16_t exp;
         got = result[1];
         exp = 45419;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 1 ",
                      exp,
                      got);
            }
      }
      {
         poly16_t got;
         poly16_t exp;
         got = result[2];
         exp = 24928;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 2 ",
                      exp,
                      got);
            }
      }
      {
         poly16_t got;
         poly16_t exp;
         got = result[3];
         exp = 43989;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 3 ",
                      exp,
                      got);
            }
      }
      {
         poly16_t got;
         poly16_t exp;
         got = result[4];
         exp = 26613;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 4 ",
                      exp,
                      got);
            }
      }
      {
         poly16_t got;
         poly16_t exp;
         got = result[5];
         exp = 20696;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 5 ",
                      exp,
                      got);
            }
      }
      {
         poly16_t got;
         poly16_t exp;
         got = result[6];
         exp = 32832;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 6 ",
                      exp,
                      got);
            }
      }
      {
         poly16_t got;
         poly16_t exp;
         got = result[7];
         exp = 52262;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 7 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1278() {
#if __ARM_NEON_FP16_INTRINSICS

{
   {
      float16x8_t arg2;
      __fp16 result[8];
      char* str1 = "ReproInfo2 {semantics = \"store1\", fnname = \"vst1q_f16\", rettype = \"__transfersize(8) __fp16 *\", argtypes = \"[/* result holder */,float16x8_t]\", vals = [PtrVal [],VectorVal [FloatVal (-2.875503108148658),FloatVal (-9.65160559664806),FloatVal 2.6462085704445926,FloatVal (-8.632634742376194),FloatVal 1.874423766427027,FloatVal 0.6639863032860767,FloatVal 3.812995496084051,FloatVal (-3.1447163102378406)]], start_saturated = False}";
      int reported = 0;
      arg2 = vcombine_f16(vcreate_f16(UINT64_C(0xc850414ac8d3c1c0)),
                          vcreate_f16(UINT64_C(0xc24a43a0394f3f7f)));
      clear_neon_saturated();
      vst1q_f16(result, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         __fp16 got;
         __fp16 exp;
         got = result[0];
         exp = -2.875503108148658;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 0 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = result[1];
         exp = -9.65160559664806;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 1 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = result[2];
         exp = 2.6462085704445926;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 2 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = result[3];
         exp = -8.632634742376194;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 3 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = result[4];
         exp = 1.874423766427027;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 4 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = result[5];
         exp = 0.6639863032860767;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 5 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = result[6];
         exp = 3.812995496084051;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 6 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = result[7];
         exp = -3.1447163102378406;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 7 ", exp, got);
            }
      }
   }
}
#endif
}
void dotests_1279() {

{
   {
      poly64x2_t arg2;
      poly64_t result[2];
      char* str1 = "ReproInfo2 {semantics = \"store1\", fnname = \"vst1q_p64\", rettype = \"__transfersize(2) poly64_t *\", argtypes = \"[/* result holder */,poly64x2_t]\", vals = [PtrVal [],VectorVal [PolyVal [0,0,0,0,1,1,1,1,0,1,0,0,1,1,1,1,1,0,1,1,0,1,1,0,0,1,1,1,1,1,0,1,1,0,1,1,1,0,1,1,1,0,1,0,0,1,1,0,0,1,1,0,1,0,0,0,0,0,1,1,1,1,0,0],PolyVal [1,1,0,0,1,1,1,0,0,1,1,1,1,1,0,0,0,1,0,0,1,0,0,1,0,1,1,0,1,0,0,0,1,0,1,1,0,1,1,1,0,0,0,1,0,0,0,1,0,1,0,1,1,1,1,0,1,1,0,0,0,1,1,0]]], start_saturated = False}";
      int reported = 0;
      arg2 = vcombine_p64(vcreate_p64(UINT64_C(0x3c1665ddbe6df2f0)),
                          vcreate_p64(UINT64_C(0x637a88ed16923e73)));
      clear_neon_saturated();
      vst1q_p64(result, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         poly64_t got;
         poly64_t exp;
         got = result[0];
         exp = 4329760094820365040;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu64 " Got: %" PRIu64 "\n",
                      "   Elem 0 ",
                      exp,
                      got);
            }
      }
      {
         poly64_t got;
         poly64_t exp;
         got = result[1];
         exp = 7168192308780875379;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu64 " Got: %" PRIu64 "\n",
                      "   Elem 1 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1280() {

{
   {
      uint8x8_t arg2;
      uint8_t result[8];
      char* str1 = "ReproInfo2 {semantics = \"store1\", fnname = \"vst1_u8\", rettype = \"__transfersize(8) uint8_t *\", argtypes = \"[/* result holder */,uint8x8_t]\", vals = [PtrVal [],VectorVal [IntegerVal 0,IntegerVal 0,IntegerVal 128,IntegerVal 128,IntegerVal 128,IntegerVal 127,IntegerVal 196,IntegerVal 127]], start_saturated = False}";
      int reported = 0;
      arg2 = vcreate_u8(UINT64_C(0x7fc47f8080800000));
      clear_neon_saturated();
      vst1_u8(result, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint8_t got;
         uint8_t exp;
         got = result[0];
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 0 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[1];
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 1 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[2];
         exp = 128U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 2 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[3];
         exp = 128U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 3 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[4];
         exp = 128U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 4 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[5];
         exp = 127U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 5 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[6];
         exp = 196U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 6 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[7];
         exp = 127U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 7 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1281() {

{
   {
      uint16x4_t arg2;
      uint16_t result[4];
      char* str1 = "ReproInfo2 {semantics = \"store1\", fnname = \"vst1_u16\", rettype = \"__transfersize(4) uint16_t *\", argtypes = \"[/* result holder */,uint16x4_t]\", vals = [PtrVal [],VectorVal [IntegerVal 32768,IntegerVal 43852,IntegerVal 29409,IntegerVal 65535]], start_saturated = False}";
      int reported = 0;
      arg2 = vcreate_u16(UINT64_C(0xffff72e1ab4c8000));
      clear_neon_saturated();
      vst1_u16(result, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint16_t got;
         uint16_t exp;
         got = result[0];
         exp = 32768U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 0 ",
                      exp,
                      got);
            }
      }
      {
         uint16_t got;
         uint16_t exp;
         got = result[1];
         exp = 43852U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 1 ",
                      exp,
                      got);
            }
      }
      {
         uint16_t got;
         uint16_t exp;
         got = result[2];
         exp = 29409U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 2 ",
                      exp,
                      got);
            }
      }
      {
         uint16_t got;
         uint16_t exp;
         got = result[3];
         exp = 65535U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 3 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1282() {

{
   {
      uint32x2_t arg2;
      uint32_t result[2];
      char* str1 = "ReproInfo2 {semantics = \"store1\", fnname = \"vst1_u32\", rettype = \"__transfersize(2) uint32_t *\", argtypes = \"[/* result holder */,uint32x2_t]\", vals = [PtrVal [],VectorVal [IntegerVal 2147450879,IntegerVal 32768]], start_saturated = False}";
      int reported = 0;
      arg2 = vcreate_u32(UINT64_C(0x000080007fff7fff));
      clear_neon_saturated();
      vst1_u32(result, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint32_t got;
         uint32_t exp;
         got = result[0];
         exp = 2147450879U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu32 " Got: %" PRIu32 "\n",
                      "   Elem 0 ",
                      exp,
                      got);
            }
      }
      {
         uint32_t got;
         uint32_t exp;
         got = result[1];
         exp = 32768U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu32 " Got: %" PRIu32 "\n",
                      "   Elem 1 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1283() {

{
   {
      uint64x1_t arg2;
      uint64_t result[1];
      char* str1 = "ReproInfo2 {semantics = \"store1\", fnname = \"vst1_u64\", rettype = \"__transfersize(1) uint64_t *\", argtypes = \"[/* result holder */,uint64x1_t]\", vals = [PtrVal [],VectorVal [IntegerVal 18446603340516152337]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg2 = vcreate_u64(UINT64_C(0xffff8000ffffd411));
      clear_neon_saturated();
      vst1_u64(result, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result[0];
      exp = UINT64_C(0xffff8000ffffd411);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   Elem 0 ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1284() {

{
   {
      int8x8_t arg2;
      int8_t result[8];
      char* str1 = "ReproInfo2 {semantics = \"store1\", fnname = \"vst1_s8\", rettype = \"__transfersize(8) int8_t *\", argtypes = \"[/* result holder */,int8x8_t]\", vals = [PtrVal [],VectorVal [IntegerVal 127,IntegerVal 127,IntegerVal (-1),IntegerVal 127,IntegerVal (-128),IntegerVal (-1),IntegerVal (-128),IntegerVal 0]], start_saturated = False}";
      int reported = 0;
      arg2 = vcreate_s8(UINT64_C(0x0080ff807fff7f7f));
      clear_neon_saturated();
      vst1_s8(result, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         int8_t got;
         int8_t exp;
         got = result[0];
         exp = 127;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 0 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[1];
         exp = 127;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 1 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[2];
         exp = -1;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 2 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[3];
         exp = 127;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 3 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[4];
         exp = -128;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 4 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[5];
         exp = -1;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 5 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[6];
         exp = -128;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 6 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[7];
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 7 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1285() {

{
   {
      int16x4_t arg2;
      int16_t result[4];
      char* str1 = "ReproInfo2 {semantics = \"store1\", fnname = \"vst1_s16\", rettype = \"__transfersize(4) int16_t *\", argtypes = \"[/* result holder */,int16x4_t]\", vals = [PtrVal [],VectorVal [IntegerVal (-32768),IntegerVal 0,IntegerVal (-1),IntegerVal (-32768)]], start_saturated = False}";
      int reported = 0;
      arg2 = vcreate_s16(UINT64_C(0x8000ffff00008000));
      clear_neon_saturated();
      vst1_s16(result, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         int16_t got;
         int16_t exp;
         got = result[0];
         exp = -32768;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi16 " Got: %" PRIi16 "\n",
                      "   Elem 0 ",
                      exp,
                      got);
            }
      }
      {
         int16_t got;
         int16_t exp;
         got = result[1];
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi16 " Got: %" PRIi16 "\n",
                      "   Elem 1 ",
                      exp,
                      got);
            }
      }
      {
         int16_t got;
         int16_t exp;
         got = result[2];
         exp = -1;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi16 " Got: %" PRIi16 "\n",
                      "   Elem 2 ",
                      exp,
                      got);
            }
      }
      {
         int16_t got;
         int16_t exp;
         got = result[3];
         exp = -32768;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi16 " Got: %" PRIi16 "\n",
                      "   Elem 3 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1286() {

{
   {
      int32x2_t arg2;
      int32_t result[2];
      char* str1 = "ReproInfo2 {semantics = \"store1\", fnname = \"vst1_s32\", rettype = \"__transfersize(2) int32_t *\", argtypes = \"[/* result holder */,int32x2_t]\", vals = [PtrVal [],VectorVal [IntegerVal 2147426554,IntegerVal 32768]], start_saturated = False}";
      int reported = 0;
      arg2 = vcreate_s32(UINT64_C(0x000080007fff20fa));
      clear_neon_saturated();
      vst1_s32(result, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         int32_t got;
         int32_t exp;
         got = result[0];
         exp = 2147426554;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi32 " Got: %" PRIi32 "\n",
                      "   Elem 0 ",
                      exp,
                      got);
            }
      }
      {
         int32_t got;
         int32_t exp;
         got = result[1];
         exp = 32768;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi32 " Got: %" PRIi32 "\n",
                      "   Elem 1 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1287() {

{
   {
      int64x1_t arg2;
      int64_t result[1];
      char* str1 = "ReproInfo2 {semantics = \"store1\", fnname = \"vst1_s64\", rettype = \"__transfersize(1) int64_t *\", argtypes = \"[/* result holder */,int64x1_t]\", vals = [PtrVal [],VectorVal [IntegerVal 9223372032559841279]], start_saturated = False}";
      int reported = 0;
      int64_t got;
      int64_t exp;
      arg2 = vcreate_s64(UINT64_C(0x7fffffff00007fff));
      clear_neon_saturated();
      vst1_s64(result, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result[0];
      exp = INT64_C(9223372032559841279);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIi64 " Got: %" PRIi64 "\n",
                   "   Elem 0 ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1288() {

{
   {
      float32x2_t arg2;
      float32_t result[2];
      char* str1 = "ReproInfo2 {semantics = \"store1\", fnname = \"vst1_f32\", rettype = \"__transfersize(2) float32_t *\", argtypes = \"[/* result holder */,float32x2_t]\", vals = [PtrVal [],VectorVal [FloatVal 0.9274471998214722,FloatVal 0.7023735642433167]], start_saturated = False}";
      int reported = 0;
      arg2 = vcreate_f32(UINT64_C(0x3f33cec13f6d6d2e));
      clear_neon_saturated();
      vst1_f32(result, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = result[0];
         exp = ((float32_t) 0.9274471998214722);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 0 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = result[1];
         exp = ((float32_t) 0.7023735642433167);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 1 ", exp, got);
            }
      }
   }
}
}
void dotests_1289() {

{
   {
      float64x1_t arg2;
      float64_t result[1];
      char* str1 = "ReproInfo2 {semantics = \"store1\", fnname = \"vst1_f64\", rettype = \"__transfersize(1) float64_t *\", argtypes = \"[/* result holder */,float64x1_t]\", vals = [PtrVal [],VectorVal [FloatVal 0.4870792213875109]], start_saturated = False}";
      int reported = 0;
      float64_t got;
      float64_t exp;
      arg2 = vcreate_f64(UINT64_C(0x3fdf2c4e539ae986));
      clear_neon_saturated();
      vst1_f64(result, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result[0];
      exp = 0.4870792213875109;
      if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %f Got: %f\n", "   Elem 0 ", exp, got);
         }
   }
}
}
void dotests_1290() {

{
   {
      poly8x8_t arg2;
      poly8_t result[8];
      char* str1 = "ReproInfo2 {semantics = \"store1\", fnname = \"vst1_p8\", rettype = \"__transfersize(8) poly8_t *\", argtypes = \"[/* result holder */,poly8x8_t]\", vals = [PtrVal [],VectorVal [PolyVal [0,0,1,0,1,0,0,1],PolyVal [0,1,0,0,0,0,0,1],PolyVal [0,0,1,0,1,0,0,0],PolyVal [0,1,1,1,1,1,0,0],PolyVal [0,0,1,0,1,1,0,1],PolyVal [1,1,0,0,0,1,1,0],PolyVal [0,1,0,1,1,1,0,1],PolyVal [1,1,0,1,0,1,0,0]]], start_saturated = False}";
      int reported = 0;
      arg2 = vcreate_p8(UINT64_C(0x2bba63b43e148294));
      clear_neon_saturated();
      vst1_p8(result, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         poly8_t got;
         poly8_t exp;
         got = result[0];
         exp = 148;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 0 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[1];
         exp = 130;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 1 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[2];
         exp = 20;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 2 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[3];
         exp = 62;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 3 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[4];
         exp = 180;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 4 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[5];
         exp = 99;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 5 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[6];
         exp = 186;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 6 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[7];
         exp = 43;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 7 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1291() {

{
   {
      poly16x4_t arg2;
      poly16_t result[4];
      char* str1 = "ReproInfo2 {semantics = \"store1\", fnname = \"vst1_p16\", rettype = \"__transfersize(4) poly16_t *\", argtypes = \"[/* result holder */,poly16x4_t]\", vals = [PtrVal [],VectorVal [PolyVal [0,1,1,0,1,1,0,1,1,0,1,1,0,0,0,0],PolyVal [0,1,0,1,0,0,1,0,0,0,1,1,0,1,0,0],PolyVal [1,0,1,1,0,1,1,0,1,0,1,0,1,1,0,1],PolyVal [1,0,1,0,0,0,1,1,1,0,1,0,1,0,0,1]]], start_saturated = False}";
      int reported = 0;
      arg2 = vcreate_p16(UINT64_C(0x95c5b56d2c4a0db6));
      clear_neon_saturated();
      vst1_p16(result, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         poly16_t got;
         poly16_t exp;
         got = result[0];
         exp = 3510;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 0 ",
                      exp,
                      got);
            }
      }
      {
         poly16_t got;
         poly16_t exp;
         got = result[1];
         exp = 11338;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 1 ",
                      exp,
                      got);
            }
      }
      {
         poly16_t got;
         poly16_t exp;
         got = result[2];
         exp = 46445;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 2 ",
                      exp,
                      got);
            }
      }
      {
         poly16_t got;
         poly16_t exp;
         got = result[3];
         exp = 38341;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 3 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1292() {
#if __ARM_NEON_FP16_INTRINSICS

{
   {
      float16x4_t arg2;
      __fp16 result[4];
      char* str1 = "ReproInfo2 {semantics = \"store1\", fnname = \"vst1_f16\", rettype = \"__transfersize(4) __fp16 *\", argtypes = \"[/* result holder */,float16x4_t]\", vals = [PtrVal [],VectorVal [FloatVal 9.789785067816918,FloatVal 0.594019065785405,FloatVal (-3.532715883466569),FloatVal (-1.7787241855881515)]], start_saturated = False}";
      int reported = 0;
      arg2 = vcreate_f16(UINT64_C(0xbf1dc31038c048e5));
      clear_neon_saturated();
      vst1_f16(result, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         __fp16 got;
         __fp16 exp;
         got = result[0];
         exp = 9.789785067816918;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 0 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = result[1];
         exp = 0.594019065785405;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 1 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = result[2];
         exp = -3.532715883466569;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 2 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = result[3];
         exp = -1.7787241855881515;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 3 ", exp, got);
            }
      }
   }
}
#endif
}
void dotests_1293() {

{
   {
      poly64x1_t arg2;
      poly64_t result[1];
      char* str1 = "ReproInfo2 {semantics = \"store1\", fnname = \"vst1_p64\", rettype = \"__transfersize(1) poly64_t *\", argtypes = \"[/* result holder */,poly64x1_t]\", vals = [PtrVal [],VectorVal [PolyVal [0,1,0,0,0,1,1,0,0,1,1,0,0,1,1,0,0,0,0,1,0,0,0,1,1,1,1,1,0,1,1,1,0,1,1,1,1,0,1,1,1,1,0,1,1,1,0,0,0,1,1,1,1,1,0,0,0,0,1,0,1,1,0,0]]], start_saturated = False}";
      int reported = 0;
      poly64_t got;
      poly64_t exp;
      arg2 = vcreate_p64(UINT64_C(0x343e3bdeef886662));
      clear_neon_saturated();
      vst1_p64(result, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result[0];
      exp = 3764512167215785570;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIu64 " Got: %" PRIu64 "\n",
                   "   Elem 0 ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1294() {

{
   {
      uint8x16_t arg2;
      uint8_t result[1];
      char* str1 = "ReproInfo2 {semantics = \"store1_lane\", fnname = \"vst1q_lane_u8\", rettype = \"__transfersize(1) uint8_t *\", argtypes = \"[/* result holder */,uint8x16_t,__constrange(0,15) int]\", vals = [PtrVal [],VectorVal [IntegerVal 145,IntegerVal 127,IntegerVal 255,IntegerVal 128,IntegerVal 128,IntegerVal 0,IntegerVal 128,IntegerVal 255,IntegerVal 1,IntegerVal 128,IntegerVal 12,IntegerVal 128,IntegerVal 255,IntegerVal 0,IntegerVal 0,IntegerVal 0],IndexVal 14], start_saturated = False}";
      int reported = 0;
      uint8_t got;
      uint8_t exp;
      arg2 = vcombine_u8(vcreate_u8(UINT64_C(0xff80008080ff7f91)),
                         vcreate_u8(UINT64_C(0x000000ff800c8001)));
      clear_neon_saturated();
      vst1q_lane_u8(result, arg2, 14);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result[0];
      exp = 0;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                   "   Elem 0 ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1295() {

{
   {
      uint16x8_t arg2;
      uint16_t result[1];
      char* str1 = "ReproInfo2 {semantics = \"store1_lane\", fnname = \"vst1q_lane_u16\", rettype = \"__transfersize(1) uint16_t *\", argtypes = \"[/* result holder */,uint16x8_t,__constrange(0,7) int]\", vals = [PtrVal [],VectorVal [IntegerVal 0,IntegerVal 32767,IntegerVal 0,IntegerVal 32767,IntegerVal 32768,IntegerVal 32768,IntegerVal 65535,IntegerVal 32767],IndexVal 6], start_saturated = False}";
      int reported = 0;
      uint16_t got;
      uint16_t exp;
      arg2 = vcombine_u16(vcreate_u16(UINT64_C(0x7fff00007fff0000)),
                          vcreate_u16(UINT64_C(0x7fffffff80008000)));
      clear_neon_saturated();
      vst1q_lane_u16(result, arg2, 6);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result[0];
      exp = 65535U;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                   "   Elem 0 ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1296() {

{
   {
      uint32x4_t arg2;
      uint32_t result[1];
      char* str1 = "ReproInfo2 {semantics = \"store1_lane\", fnname = \"vst1q_lane_u32\", rettype = \"__transfersize(1) uint32_t *\", argtypes = \"[/* result holder */,uint32x4_t,__constrange(0,3) int]\", vals = [PtrVal [],VectorVal [IntegerVal 2147450879,IntegerVal 65535,IntegerVal 2147483648,IntegerVal 2558001152],IndexVal 2], start_saturated = False}";
      int reported = 0;
      uint32_t got;
      uint32_t exp;
      arg2 = vcombine_u32(vcreate_u32(UINT64_C(0x0000ffff7fff7fff)),
                          vcreate_u32(UINT64_C(0x9878000080000000)));
      clear_neon_saturated();
      vst1q_lane_u32(result, arg2, 2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result[0];
      exp = 2147483648U;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIu32 " Got: %" PRIu32 "\n",
                   "   Elem 0 ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1297() {

{
   {
      uint64x2_t arg2;
      uint64_t result[1];
      char* str1 = "ReproInfo2 {semantics = \"store1_lane\", fnname = \"vst1q_lane_u64\", rettype = \"__transfersize(1) uint64_t *\", argtypes = \"[/* result holder */,uint64x2_t,__constrange(0,1) int]\", vals = [PtrVal [],VectorVal [IntegerVal 9223231301513871360,IntegerVal 18446603334073647104],IndexVal 1], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg2 = vcombine_u64(vcreate_u64(UINT64_C(0x7fff80007fff8000)),
                          vcreate_u64(UINT64_C(0xffff7fff7fff0000)));
      clear_neon_saturated();
      vst1q_lane_u64(result, arg2, 1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result[0];
      exp = UINT64_C(0xffff7fff7fff0000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   Elem 0 ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1298() {

{
   {
      int8x16_t arg2;
      int8_t result[1];
      char* str1 = "ReproInfo2 {semantics = \"store1_lane\", fnname = \"vst1q_lane_s8\", rettype = \"__transfersize(1) int8_t *\", argtypes = \"[/* result holder */,int8x16_t,__constrange(0,15) int]\", vals = [PtrVal [],VectorVal [IntegerVal (-3),IntegerVal (-128),IntegerVal 127,IntegerVal 127,IntegerVal (-1),IntegerVal (-1),IntegerVal (-128),IntegerVal (-108),IntegerVal 0,IntegerVal 0,IntegerVal 127,IntegerVal 0,IntegerVal 127,IntegerVal (-74),IntegerVal 127,IntegerVal (-1)],IndexVal 9], start_saturated = False}";
      int reported = 0;
      int8_t got;
      int8_t exp;
      arg2 = vcombine_s8(vcreate_s8(UINT64_C(0x9480ffff7f7f80fd)),
                         vcreate_s8(UINT64_C(0xff7fb67f007f0000)));
      clear_neon_saturated();
      vst1q_lane_s8(result, arg2, 9);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result[0];
      exp = 0;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                   "   Elem 0 ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1299() {

{
   {
      int16x8_t arg2;
      int16_t result[1];
      char* str1 = "ReproInfo2 {semantics = \"store1_lane\", fnname = \"vst1q_lane_s16\", rettype = \"__transfersize(1) int16_t *\", argtypes = \"[/* result holder */,int16x8_t,__constrange(0,7) int]\", vals = [PtrVal [],VectorVal [IntegerVal (-32768),IntegerVal (-32768),IntegerVal (-32768),IntegerVal 32767,IntegerVal (-8308),IntegerVal 0,IntegerVal (-32768),IntegerVal (-32768)],IndexVal 0], start_saturated = False}";
      int reported = 0;
      int16_t got;
      int16_t exp;
      arg2 = vcombine_s16(vcreate_s16(UINT64_C(0x7fff800080008000)),
                          vcreate_s16(UINT64_C(0x800080000000df8c)));
      clear_neon_saturated();
      vst1q_lane_s16(result, arg2, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result[0];
      exp = -32768;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIi16 " Got: %" PRIi16 "\n",
                   "   Elem 0 ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1300() {

{
   {
      int32x4_t arg2;
      int32_t result[1];
      char* str1 = "ReproInfo2 {semantics = \"store1_lane\", fnname = \"vst1q_lane_s32\", rettype = \"__transfersize(1) int32_t *\", argtypes = \"[/* result holder */,int32x4_t,__constrange(0,3) int]\", vals = [PtrVal [],VectorVal [IntegerVal 615481344,IntegerVal (-32769),IntegerVal (-1132298240),IntegerVal (-57442305)],IndexVal 2], start_saturated = False}";
      int reported = 0;
      int32_t got;
      int32_t exp;
      arg2 = vcombine_s32(vcreate_s32(UINT64_C(0xffff7fff24af8000)),
                          vcreate_s32(UINT64_C(0xfc937fffbc828000)));
      clear_neon_saturated();
      vst1q_lane_s32(result, arg2, 2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result[0];
      exp = -1132298240;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIi32 " Got: %" PRIi32 "\n",
                   "   Elem 0 ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1301() {

{
   {
      int64x2_t arg2;
      int64_t result[1];
      char* str1 = "ReproInfo2 {semantics = \"store1_lane\", fnname = \"vst1q_lane_s64\", rettype = \"__transfersize(1) int64_t *\", argtypes = \"[/* result holder */,int64x2_t,__constrange(0,1) int]\", vals = [PtrVal [],VectorVal [IntegerVal 140735340838911,IntegerVal (-9223090564025483265)],IndexVal 0], start_saturated = False}";
      int reported = 0;
      int64_t got;
      int64_t exp;
      arg2 = vcombine_s64(vcreate_s64(UINT64_C(0x00007fff7fff7fff)),
                          vcreate_s64(UINT64_C(0x8000ffff8000ffff)));
      clear_neon_saturated();
      vst1q_lane_s64(result, arg2, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result[0];
      exp = INT64_C(140735340838911);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIi64 " Got: %" PRIi64 "\n",
                   "   Elem 0 ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1302() {

{
   {
      float32x4_t arg2;
      float32_t result[1];
      char* str1 = "ReproInfo2 {semantics = \"store1_lane\", fnname = \"vst1q_lane_f32\", rettype = \"__transfersize(1) float32_t *\", argtypes = \"[/* result holder */,float32x4_t,__constrange(0,3) int]\", vals = [PtrVal [],VectorVal [FloatVal 0.6385444402694702,FloatVal 0.270965039730072,FloatVal 0.9847959280014038,FloatVal 4.6726882457733154e-2],IndexVal 1], start_saturated = False}";
      int reported = 0;
      float32_t got;
      float32_t exp;
      arg2 = vcombine_f32(vcreate_f32(UINT64_C(0x3e8abbee3f2377a6)),
                          vcreate_f32(UINT64_C(0x3d3f64b03f7c1b96)));
      clear_neon_saturated();
      vst1q_lane_f32(result, arg2, 1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result[0];
      exp = ((float32_t) 0.270965039730072);
      if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %f Got: %f\n", "   Elem 0 ", exp, got);
         }
   }
}
}
void dotests_1303() {

{
   {
      float64x2_t arg2;
      float64_t result[1];
      char* str1 = "ReproInfo2 {semantics = \"store1_lane\", fnname = \"vst1q_lane_f64\", rettype = \"__transfersize(1) float64_t *\", argtypes = \"[/* result holder */,float64x2_t,__constrange(0,1) int]\", vals = [PtrVal [],VectorVal [FloatVal 0.9387978128223632,FloatVal 0.13395633740710622],IndexVal 1], start_saturated = True}";
      int reported = 0;
      float64_t got;
      float64_t exp;
      arg2 = vcombine_f64(vcreate_f64(UINT64_C(0x3fee0aa1b5f41baf)),
                          vcreate_f64(UINT64_C(0x3fc1257b3420b300)));
      set_neon_saturated();
      vst1q_lane_f64(result, arg2, 1);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      got = result[0];
      exp = 0.13395633740710622;
      if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %f Got: %f\n", "   Elem 0 ", exp, got);
         }
   }
}
}
void dotests_1304() {

{
   {
      poly8x16_t arg2;
      poly8_t result[1];
      char* str1 = "ReproInfo2 {semantics = \"store1_lane\", fnname = \"vst1q_lane_p8\", rettype = \"__transfersize(1) poly8_t *\", argtypes = \"[/* result holder */,poly8x16_t,__constrange(0,15) int]\", vals = [PtrVal [],VectorVal [PolyVal [1,0,0,0,1,1,0,0],PolyVal [0,0,0,1,1,0,0,1],PolyVal [0,1,0,0,1,0,0,0],PolyVal [1,1,0,0,1,0,0,0],PolyVal [1,0,0,0,0,1,0,0],PolyVal [1,1,0,1,1,1,0,0],PolyVal [0,1,0,0,1,1,1,1],PolyVal [0,0,0,0,1,1,0,1],PolyVal [1,0,0,1,1,1,1,1],PolyVal [0,1,1,1,1,0,1,0],PolyVal [1,0,1,0,1,1,0,0],PolyVal [0,0,1,0,1,0,1,1],PolyVal [1,0,0,1,1,0,0,0],PolyVal [1,0,1,1,1,0,0,0],PolyVal [1,0,0,1,1,0,1,0],PolyVal [0,0,1,1,1,1,1,0]],IndexVal 11], start_saturated = False}";
      int reported = 0;
      poly8_t got;
      poly8_t exp;
      arg2 = vcombine_p8(vcreate_p8(UINT64_C(0xb0f23b2113129831)),
                         vcreate_p8(UINT64_C(0x7c591d19d4355ef9)));
      clear_neon_saturated();
      vst1q_lane_p8(result, arg2, 11);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result[0];
      exp = 212;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                   "   Elem 0 ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1305() {

{
   {
      poly16x8_t arg2;
      poly16_t result[1];
      char* str1 = "ReproInfo2 {semantics = \"store1_lane\", fnname = \"vst1q_lane_p16\", rettype = \"__transfersize(1) poly16_t *\", argtypes = \"[/* result holder */,poly16x8_t,__constrange(0,7) int]\", vals = [PtrVal [],VectorVal [PolyVal [0,1,0,0,1,1,1,0,0,0,1,0,0,0,0,0],PolyVal [1,1,1,1,1,0,0,0,0,0,0,1,0,0,0,1],PolyVal [0,1,1,0,0,1,1,0,0,0,1,0,0,1,0,0],PolyVal [1,0,0,0,0,1,1,1,0,1,1,0,0,1,1,0],PolyVal [1,0,0,0,0,0,0,0,0,1,0,1,1,0,1,1],PolyVal [0,0,0,1,1,0,0,0,1,0,1,1,0,0,1,0],PolyVal [1,0,0,1,0,0,0,1,0,1,1,1,1,1,1,0],PolyVal [1,1,0,1,1,0,0,1,1,1,0,0,1,0,0,0]],IndexVal 4], start_saturated = False}";
      int reported = 0;
      poly16_t got;
      poly16_t exp;
      arg2 = vcombine_p16(vcreate_p16(UINT64_C(0x66e12466881f0472)),
                          vcreate_p16(UINT64_C(0x139b7e894d18da01)));
      clear_neon_saturated();
      vst1q_lane_p16(result, arg2, 4);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result[0];
      exp = 55809;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                   "   Elem 0 ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1306() {
#if __ARM_NEON_FP16_INTRINSICS

{
   {
      float16x8_t arg2;
      __fp16 result[1];
      char* str1 = "ReproInfo2 {semantics = \"store1_lane\", fnname = \"vst1q_lane_f16\", rettype = \"__transfersize(1) __fp16 *\", argtypes = \"[/* result holder */,float16x8_t,__constrange(0,7) int]\", vals = [PtrVal [],VectorVal [FloatVal 1.2377538491616686,FloatVal 3.334110459572482,FloatVal (-5.469685957280932),FloatVal 3.8093010857619607,FloatVal 5.742385100742542,FloatVal 0.12443029138378847,FloatVal (-0.15287182493567286),FloatVal 8.822496713189249],IndexVal 5], start_saturated = False}";
      int reported = 0;
      __fp16 got;
      __fp16 exp;
      arg2 = vcombine_f16(vcreate_f16(UINT64_C(0x439ec57842ab3cf3)),
                          vcreate_f16(UINT64_C(0x4869b0e42ff645be)));
      clear_neon_saturated();
      vst1q_lane_f16(result, arg2, 5);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result[0];
      exp = 0.12443029138378847;
      if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %f Got: %f\n", "   Elem 0 ", exp, got);
         }
   }
}
#endif
}
void dotests_1307() {

{
   {
      poly64x2_t arg2;
      poly64_t result[1];
      char* str1 = "ReproInfo2 {semantics = \"store1_lane\", fnname = \"vst1q_lane_p64\", rettype = \"__transfersize(1) poly64_t *\", argtypes = \"[/* result holder */,poly64x2_t,__constrange(0,1) int]\", vals = [PtrVal [],VectorVal [PolyVal [0,0,0,0,1,1,1,0,1,0,1,1,1,1,1,0,0,1,1,1,1,1,0,0,1,1,0,1,1,1,0,1,0,1,1,0,1,1,1,1,1,0,1,0,1,1,1,0,1,1,1,1,0,1,0,1,0,0,0,1,1,0,0,0],PolyVal [0,1,0,0,1,0,0,1,1,0,0,1,0,0,1,1,1,0,1,0,0,0,0,1,1,1,0,1,0,0,0,1,1,1,1,0,1,0,0,0,1,1,0,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,0,0,1,1,0,1]],IndexVal 1], start_saturated = False}";
      int reported = 0;
      poly64_t got;
      poly64_t exp;
      arg2 = vcombine_p64(vcreate_p64(UINT64_C(0x18af75f6bb3e7d70)),
                          vcreate_p64(UINT64_C(0xb201fb178b85c992)));
      clear_neon_saturated();
      vst1q_lane_p64(result, arg2, 1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result[0];
      exp = -5619934781438047854;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIu64 " Got: %" PRIu64 "\n",
                   "   Elem 0 ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1308() {

{
   {
      uint8x8_t arg2;
      uint8_t result[1];
      char* str1 = "ReproInfo2 {semantics = \"store1_lane\", fnname = \"vst1_lane_u8\", rettype = \"__transfersize(1) uint8_t *\", argtypes = \"[/* result holder */,uint8x8_t,__constrange(0,7) int]\", vals = [PtrVal [],VectorVal [IntegerVal 128,IntegerVal 0,IntegerVal 36,IntegerVal 180,IntegerVal 0,IntegerVal 0,IntegerVal 127,IntegerVal 128],IndexVal 1], start_saturated = False}";
      int reported = 0;
      uint8_t got;
      uint8_t exp;
      arg2 = vcreate_u8(UINT64_C(0x807f0000b4240080));
      clear_neon_saturated();
      vst1_lane_u8(result, arg2, 1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result[0];
      exp = 0;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                   "   Elem 0 ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1309() {

{
   {
      uint16x4_t arg2;
      uint16_t result[1];
      char* str1 = "ReproInfo2 {semantics = \"store1_lane\", fnname = \"vst1_lane_u16\", rettype = \"__transfersize(1) uint16_t *\", argtypes = \"[/* result holder */,uint16x4_t,__constrange(0,3) int]\", vals = [PtrVal [],VectorVal [IntegerVal 19922,IntegerVal 65535,IntegerVal 0,IntegerVal 65535],IndexVal 0], start_saturated = False}";
      int reported = 0;
      uint16_t got;
      uint16_t exp;
      arg2 = vcreate_u16(UINT64_C(0xffff0000ffff4dd2));
      clear_neon_saturated();
      vst1_lane_u16(result, arg2, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result[0];
      exp = 19922U;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                   "   Elem 0 ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1310() {

{
   {
      uint32x2_t arg2;
      uint32_t result[1];
      char* str1 = "ReproInfo2 {semantics = \"store1_lane\", fnname = \"vst1_lane_u32\", rettype = \"__transfersize(1) uint32_t *\", argtypes = \"[/* result holder */,uint32x2_t,__constrange(0,1) int]\", vals = [PtrVal [],VectorVal [IntegerVal 32768,IntegerVal 2147462010],IndexVal 1], start_saturated = False}";
      int reported = 0;
      uint32_t got;
      uint32_t exp;
      arg2 = vcreate_u32(UINT64_C(0x7fffab7a00008000));
      clear_neon_saturated();
      vst1_lane_u32(result, arg2, 1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result[0];
      exp = 2147462010U;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIu32 " Got: %" PRIu32 "\n",
                   "   Elem 0 ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1311() {

{
   {
      uint64x1_t arg2;
      uint64_t result[1];
      char* str1 = "ReproInfo2 {semantics = \"store1_lane\", fnname = \"vst1_lane_u64\", rettype = \"__transfersize(1) uint64_t *\", argtypes = \"[/* result holder */,uint64x1_t,__constrange(0,0) int]\", vals = [PtrVal [],VectorVal [IntegerVal 969540559427371007],IndexVal 0], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg2 = vcreate_u64(UINT64_C(0x0d74800080007fff));
      clear_neon_saturated();
      vst1_lane_u64(result, arg2, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result[0];
      exp = UINT64_C(0x0d74800080007fff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   Elem 0 ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1312() {

{
   {
      int8x8_t arg2;
      int8_t result[1];
      char* str1 = "ReproInfo2 {semantics = \"store1_lane\", fnname = \"vst1_lane_s8\", rettype = \"__transfersize(1) int8_t *\", argtypes = \"[/* result holder */,int8x8_t,__constrange(0,7) int]\", vals = [PtrVal [],VectorVal [IntegerVal 53,IntegerVal (-1),IntegerVal 127,IntegerVal 0,IntegerVal 127,IntegerVal 127,IntegerVal 127,IntegerVal (-128)],IndexVal 1], start_saturated = False}";
      int reported = 0;
      int8_t got;
      int8_t exp;
      arg2 = vcreate_s8(UINT64_C(0x807f7f7f007fff35));
      clear_neon_saturated();
      vst1_lane_s8(result, arg2, 1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result[0];
      exp = -1;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                   "   Elem 0 ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1313() {

{
   {
      int16x4_t arg2;
      int16_t result[1];
      char* str1 = "ReproInfo2 {semantics = \"store1_lane\", fnname = \"vst1_lane_s16\", rettype = \"__transfersize(1) int16_t *\", argtypes = \"[/* result holder */,int16x4_t,__constrange(0,3) int]\", vals = [PtrVal [],VectorVal [IntegerVal (-1),IntegerVal 26323,IntegerVal 32767,IntegerVal (-26024)],IndexVal 1], start_saturated = False}";
      int reported = 0;
      int16_t got;
      int16_t exp;
      arg2 = vcreate_s16(UINT64_C(0x9a587fff66d3ffff));
      clear_neon_saturated();
      vst1_lane_s16(result, arg2, 1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result[0];
      exp = 26323;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIi16 " Got: %" PRIi16 "\n",
                   "   Elem 0 ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1314() {

{
   {
      int32x2_t arg2;
      int32_t result[1];
      char* str1 = "ReproInfo2 {semantics = \"store1_lane\", fnname = \"vst1_lane_s32\", rettype = \"__transfersize(1) int32_t *\", argtypes = \"[/* result holder */,int32x2_t,__constrange(0,1) int]\", vals = [PtrVal [],VectorVal [IntegerVal 2147418112,IntegerVal 179077119],IndexVal 1], start_saturated = False}";
      int reported = 0;
      int32_t got;
      int32_t exp;
      arg2 = vcreate_s32(UINT64_C(0x0aac7fff7fff0000));
      clear_neon_saturated();
      vst1_lane_s32(result, arg2, 1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result[0];
      exp = 179077119;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIi32 " Got: %" PRIi32 "\n",
                   "   Elem 0 ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1315() {

{
   {
      int64x1_t arg2;
      int64_t result[1];
      char* str1 = "ReproInfo2 {semantics = \"store1_lane\", fnname = \"vst1_lane_s64\", rettype = \"__transfersize(1) int64_t *\", argtypes = \"[/* result holder */,int64x1_t,__constrange(0,0) int]\", vals = [PtrVal [],VectorVal [IntegerVal (-7040423613383563955)],IndexVal 0], start_saturated = False}";
      int reported = 0;
      int64_t got;
      int64_t exp;
      arg2 = vcreate_s64(UINT64_C(0x9e4b64068000254d));
      clear_neon_saturated();
      vst1_lane_s64(result, arg2, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result[0];
      exp = INT64_C(-7040423613383563955);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIi64 " Got: %" PRIi64 "\n",
                   "   Elem 0 ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1316() {

{
   {
      float32x2_t arg2;
      float32_t result[1];
      char* str1 = "ReproInfo2 {semantics = \"store1_lane\", fnname = \"vst1_lane_f32\", rettype = \"__transfersize(1) float32_t *\", argtypes = \"[/* result holder */,float32x2_t,__constrange(0,1) int]\", vals = [PtrVal [],VectorVal [FloatVal 0.6961069107055664,FloatVal 0.8890774250030518],IndexVal 0], start_saturated = False}";
      int reported = 0;
      float32_t got;
      float32_t exp;
      arg2 = vcreate_f32(UINT64_C(0x3f639a943f323410));
      clear_neon_saturated();
      vst1_lane_f32(result, arg2, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result[0];
      exp = ((float32_t) 0.6961069107055664);
      if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %f Got: %f\n", "   Elem 0 ", exp, got);
         }
   }
}
}
void dotests_1317() {

{
   {
      float64x1_t arg2;
      float64_t result[1];
      char* str1 = "ReproInfo2 {semantics = \"store1_lane\", fnname = \"vst1_lane_f64\", rettype = \"__transfersize(1) float64_t *\", argtypes = \"[/* result holder */,float64x1_t,__constrange(0,0) int]\", vals = [PtrVal [],VectorVal [FloatVal 6.57087606408504e-2],IndexVal 0], start_saturated = False}";
      int reported = 0;
      float64_t got;
      float64_t exp;
      arg2 = vcreate_f64(UINT64_C(0x3fb0d24a12035d70));
      clear_neon_saturated();
      vst1_lane_f64(result, arg2, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result[0];
      exp = 6.57087606408504e-2;
      if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %f Got: %f\n", "   Elem 0 ", exp, got);
         }
   }
}
}
void dotests_1318() {

{
   {
      poly8x8_t arg2;
      poly8_t result[1];
      char* str1 = "ReproInfo2 {semantics = \"store1_lane\", fnname = \"vst1_lane_p8\", rettype = \"__transfersize(1) poly8_t *\", argtypes = \"[/* result holder */,poly8x8_t,__constrange(0,7) int]\", vals = [PtrVal [],VectorVal [PolyVal [0,1,1,1,1,0,1,0],PolyVal [1,1,1,0,1,1,1,1],PolyVal [0,0,0,1,0,1,1,0],PolyVal [1,0,0,0,0,0,0,1],PolyVal [1,1,1,0,0,0,0,0],PolyVal [0,1,0,1,0,1,0,1],PolyVal [0,1,0,1,0,1,1,0],PolyVal [0,1,1,1,0,0,0,0]],IndexVal 5], start_saturated = False}";
      int reported = 0;
      poly8_t got;
      poly8_t exp;
      arg2 = vcreate_p8(UINT64_C(0x0e6aaa078168f75e));
      clear_neon_saturated();
      vst1_lane_p8(result, arg2, 5);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result[0];
      exp = 170;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                   "   Elem 0 ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1319() {

{
   {
      poly16x4_t arg2;
      poly16_t result[1];
      char* str1 = "ReproInfo2 {semantics = \"store1_lane\", fnname = \"vst1_lane_p16\", rettype = \"__transfersize(1) poly16_t *\", argtypes = \"[/* result holder */,poly16x4_t,__constrange(0,3) int]\", vals = [PtrVal [],VectorVal [PolyVal [1,0,0,1,0,0,0,1,0,0,0,1,0,1,1,0],PolyVal [0,1,0,0,1,1,0,0,0,1,1,1,0,0,1,0],PolyVal [0,0,1,1,0,1,1,0,1,0,1,1,0,1,0,0],PolyVal [1,1,0,1,0,1,0,1,1,1,0,1,0,1,0,1]],IndexVal 0], start_saturated = False}";
      int reported = 0;
      poly16_t got;
      poly16_t exp;
      arg2 = vcreate_p16(UINT64_C(0xabab2d6c4e326889));
      clear_neon_saturated();
      vst1_lane_p16(result, arg2, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result[0];
      exp = 26761;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                   "   Elem 0 ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1320() {
#if __ARM_NEON_FP16_INTRINSICS

{
   {
      float16x4_t arg2;
      __fp16 result[1];
      char* str1 = "ReproInfo2 {semantics = \"store1_lane\", fnname = \"vst1_lane_f16\", rettype = \"__transfersize(1) __fp16 *\", argtypes = \"[/* result holder */,float16x4_t,__constrange(0,3) int]\", vals = [PtrVal [],VectorVal [FloatVal 2.49753754108651,FloatVal (-4.782385927456543),FloatVal (-8.395485113462435),FloatVal 3.6885343029656674],IndexVal 0], start_saturated = False}";
      int reported = 0;
      __fp16 got;
      __fp16 exp;
      arg2 = vcreate_f16(UINT64_C(0x4360c832c4c840fe));
      clear_neon_saturated();
      vst1_lane_f16(result, arg2, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result[0];
      exp = 2.49753754108651;
      if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %f Got: %f\n", "   Elem 0 ", exp, got);
         }
   }
}
#endif
}
void dotests_1321() {

{
   {
      poly64x1_t arg2;
      poly64_t result[1];
      char* str1 = "ReproInfo2 {semantics = \"store1_lane\", fnname = \"vst1_lane_p64\", rettype = \"__transfersize(1) poly64_t *\", argtypes = \"[/* result holder */,poly64x1_t,__constrange(0,0) int]\", vals = [PtrVal [],VectorVal [PolyVal [0,0,1,1,0,0,0,0,1,0,0,1,0,1,0,0,1,1,1,1,1,0,1,1,1,0,1,1,0,0,1,1,0,0,1,1,1,0,0,0,1,1,1,0,0,0,0,1,0,1,0,1,1,0,0,0,0,1,0,0,1,1,1,0]],IndexVal 0], start_saturated = False}";
      int reported = 0;
      poly64_t got;
      poly64_t exp;
      arg2 = vcreate_p64(UINT64_C(0x721a871ccddf290c));
      clear_neon_saturated();
      vst1_lane_p64(result, arg2, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result[0];
      exp = 8222032627501050124;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIu64 " Got: %" PRIu64 "\n",
                   "   Elem 0 ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1322() {

{
   {
      uint8_t arg1[32];
      uint8x16x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"load2\", fnname = \"vld2q_u8\", rettype = \"uint8x16x2_t\", argtypes = \"[__transfersize(32) uint8_t const *]\", vals = [PtrVal [IntegerVal 255,IntegerVal 0,IntegerVal 128,IntegerVal 0,IntegerVal 0,IntegerVal 0,IntegerVal 77,IntegerVal 0,IntegerVal 127,IntegerVal 127,IntegerVal 255,IntegerVal 0,IntegerVal 255,IntegerVal 255,IntegerVal 255,IntegerVal 127,IntegerVal 69,IntegerVal 0,IntegerVal 128,IntegerVal 128,IntegerVal 186,IntegerVal 46,IntegerVal 128,IntegerVal 127,IntegerVal 0,IntegerVal 127,IntegerVal 144,IntegerVal 0,IntegerVal 255,IntegerVal 127,IntegerVal 128,IntegerVal 255]], start_saturated = False}";
      int reported = 0;
      arg1[0] = 255U;
      arg1[1] = 0;
      arg1[2] = 128U;
      arg1[3] = 0;
      arg1[4] = 0;
      arg1[5] = 0;
      arg1[6] = 77U;
      arg1[7] = 0;
      arg1[8] = 127U;
      arg1[9] = 127U;
      arg1[10] = 255U;
      arg1[11] = 0;
      arg1[12] = 255U;
      arg1[13] = 255U;
      arg1[14] = 255U;
      arg1[15] = 127U;
      arg1[16] = 69U;
      arg1[17] = 0;
      arg1[18] = 128U;
      arg1[19] = 128U;
      arg1[20] = 186U;
      arg1[21] = 46U;
      arg1[22] = 128U;
      arg1[23] = 127U;
      arg1[24] = 0;
      arg1[25] = 127U;
      arg1[26] = 144U;
      arg1[27] = 0;
      arg1[28] = 255U;
      arg1[29] = 127U;
      arg1[30] = 128U;
      arg1[31] = 255U;
      clear_neon_saturated();
      //  Expect: "result" = ff7f007f7f2e80007fff007f0000000080ff900080ba8045ffffff7f4d0080ff
      result = vld2q_u8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result.val[0]), 0);
         exp = UINT64_C(0xffffff7f4d0080ff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result.val[0]), 1);
         exp = UINT64_C(0x80ff900080ba8045);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result.val[1]), 0);
         exp = UINT64_C(0x7fff007f00000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result.val[1]), 1);
         exp = UINT64_C(0xff7f007f7f2e8000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1323() {

{
   {
      uint16_t arg1[16];
      uint16x8x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"load2\", fnname = \"vld2q_u16\", rettype = \"uint16x8x2_t\", argtypes = \"[__transfersize(16) uint16_t const *]\", vals = [PtrVal [IntegerVal 65535,IntegerVal 24138,IntegerVal 25292,IntegerVal 32768,IntegerVal 32768,IntegerVal 32767,IntegerVal 65535,IntegerVal 32768,IntegerVal 65535,IntegerVal 65535,IntegerVal 32767,IntegerVal 36897,IntegerVal 0,IntegerVal 32767,IntegerVal 65535,IntegerVal 32767]], start_saturated = False}";
      int reported = 0;
      arg1[0] = 65535U;
      arg1[1] = 24138U;
      arg1[2] = 25292U;
      arg1[3] = 32768U;
      arg1[4] = 32768U;
      arg1[5] = 32767U;
      arg1[6] = 65535U;
      arg1[7] = 32768U;
      arg1[8] = 65535U;
      arg1[9] = 65535U;
      arg1[10] = 32767U;
      arg1[11] = 36897U;
      arg1[12] = 0;
      arg1[13] = 32767U;
      arg1[14] = 65535U;
      arg1[15] = 32767U;
      clear_neon_saturated();
      //  Expect: "result" = 7fff7fff9021ffff80007fff80005e4affff00007fffffffffff800062ccffff
      result = vld2q_u16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result.val[0]), 0);
         exp = UINT64_C(0xffff800062ccffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result.val[0]), 1);
         exp = UINT64_C(0xffff00007fffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result.val[1]), 0);
         exp = UINT64_C(0x80007fff80005e4a);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result.val[1]), 1);
         exp = UINT64_C(0x7fff7fff9021ffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1324() {

{
   {
      uint32_t arg1[8];
      uint32x4x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"load2\", fnname = \"vld2q_u32\", rettype = \"uint32x4x2_t\", argtypes = \"[__transfersize(8) uint32_t const *]\", vals = [PtrVal [IntegerVal 4294934527,IntegerVal 4294934527,IntegerVal 2147450880,IntegerVal 43460,IntegerVal 4294934527,IntegerVal 3930062847,IntegerVal 2147483647,IntegerVal 2925297664]], start_saturated = False}";
      int reported = 0;
      arg1[0] = 4294934527U;
      arg1[1] = 4294934527U;
      arg1[2] = 2147450880U;
      arg1[3] = 43460U;
      arg1[4] = 4294934527U;
      arg1[5] = 3930062847U;
      arg1[6] = 2147483647U;
      arg1[7] = 2925297664U;
      clear_neon_saturated();
      //  Expect: "result" = ae5c8000ea3fffff0000a9c4ffff7fff7fffffffffff7fff7fff8000ffff7fff
      result = vld2q_u32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result.val[0]), 0);
         exp = UINT64_C(0x7fff8000ffff7fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result.val[0]), 1);
         exp = UINT64_C(0x7fffffffffff7fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result.val[1]), 0);
         exp = UINT64_C(0x0000a9c4ffff7fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result.val[1]), 1);
         exp = UINT64_C(0xae5c8000ea3fffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1325() {

{
   {
      uint64_t arg1[4];
      uint64x2x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"load2\", fnname = \"vld2q_u64\", rettype = \"uint64x2x2_t\", argtypes = \"[__transfersize(4) uint64_t const *]\", vals = [PtrVal [IntegerVal 9223413058087452671,IntegerVal 9223231301513936895,IntegerVal 9223277818157236224,IntegerVal 9223231301513905437]], start_saturated = False}";
      int reported = 0;
      arg1[0] = UINT64_C(0x8000254f00007fff);
      arg1[1] = UINT64_C(0x7fff800080007fff);
      arg1[2] = UINT64_C(0x7fffaa4f00008000);
      arg1[3] = UINT64_C(0x7fff80008000051d);
      clear_neon_saturated();
      //  Expect: "result" = 7fff80008000051d7fff800080007fff7fffaa4f000080008000254f00007fff
      result = vld2q_u64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result.val[0], 0);
         exp = UINT64_C(0x8000254f00007fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result.val[0], 1);
         exp = UINT64_C(0x7fffaa4f00008000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result.val[1], 0);
         exp = UINT64_C(0x7fff800080007fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result.val[1], 1);
         exp = UINT64_C(0x7fff80008000051d);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1326() {

{
   {
      int8_t arg1[32];
      int8x16x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"load2\", fnname = \"vld2q_s8\", rettype = \"int8x16x2_t\", argtypes = \"[__transfersize(32) int8_t const *]\", vals = [PtrVal [IntegerVal (-1),IntegerVal (-1),IntegerVal 0,IntegerVal 127,IntegerVal 127,IntegerVal (-1),IntegerVal 108,IntegerVal 0,IntegerVal 127,IntegerVal (-128),IntegerVal (-1),IntegerVal (-128),IntegerVal 17,IntegerVal (-1),IntegerVal 0,IntegerVal (-128),IntegerVal (-128),IntegerVal 127,IntegerVal (-128),IntegerVal (-1),IntegerVal 63,IntegerVal (-128),IntegerVal (-118),IntegerVal (-128),IntegerVal 0,IntegerVal 127,IntegerVal (-1),IntegerVal (-1),IntegerVal (-1),IntegerVal 0,IntegerVal (-1),IntegerVal 127]], start_saturated = False}";
      int reported = 0;
      arg1[0] = -1;
      arg1[1] = -1;
      arg1[2] = 0;
      arg1[3] = 127;
      arg1[4] = 127;
      arg1[5] = -1;
      arg1[6] = 108;
      arg1[7] = 0;
      arg1[8] = 127;
      arg1[9] = -128;
      arg1[10] = -1;
      arg1[11] = -128;
      arg1[12] = 17;
      arg1[13] = -1;
      arg1[14] = 0;
      arg1[15] = -128;
      arg1[16] = -128;
      arg1[17] = 127;
      arg1[18] = -128;
      arg1[19] = -1;
      arg1[20] = 63;
      arg1[21] = -128;
      arg1[22] = -118;
      arg1[23] = -128;
      arg1[24] = 0;
      arg1[25] = 127;
      arg1[26] = -1;
      arg1[27] = -1;
      arg1[28] = -1;
      arg1[29] = 0;
      arg1[30] = -1;
      arg1[31] = 127;
      clear_neon_saturated();
      //  Expect: "result" = 7f00ff7f8080ff7f80ff808000ff7fffffffff008a3f80800011ff7f6c7f00ff
      result = vld2q_s8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result.val[0]), 0);
         exp = UINT64_C(0x0011ff7f6c7f00ff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result.val[0]), 1);
         exp = UINT64_C(0xffffff008a3f8080);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result.val[1]), 0);
         exp = UINT64_C(0x80ff808000ff7fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result.val[1]), 1);
         exp = UINT64_C(0x7f00ff7f8080ff7f);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1327() {

{
   {
      int16_t arg1[16];
      int16x8x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"load2\", fnname = \"vld2q_s16\", rettype = \"int16x8x2_t\", argtypes = \"[__transfersize(16) int16_t const *]\", vals = [PtrVal [IntegerVal 32767,IntegerVal (-12381),IntegerVal 32767,IntegerVal (-6516),IntegerVal 4631,IntegerVal (-32768),IntegerVal (-1),IntegerVal 32767,IntegerVal (-1),IntegerVal (-32768),IntegerVal 0,IntegerVal 32767,IntegerVal (-6242),IntegerVal (-32768),IntegerVal (-32768),IntegerVal (-32768)]], start_saturated = False}";
      int reported = 0;
      arg1[0] = 32767;
      arg1[1] = -12381;
      arg1[2] = 32767;
      arg1[3] = -6516;
      arg1[4] = 4631;
      arg1[5] = -32768;
      arg1[6] = -1;
      arg1[7] = 32767;
      arg1[8] = -1;
      arg1[9] = -32768;
      arg1[10] = 0;
      arg1[11] = 32767;
      arg1[12] = -6242;
      arg1[13] = -32768;
      arg1[14] = -32768;
      arg1[15] = -32768;
      clear_neon_saturated();
      //  Expect: "result" = 800080007fff80007fff8000e68ccfa38000e79e0000ffffffff12177fff7fff
      result = vld2q_s16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result.val[0]), 0);
         exp = UINT64_C(0xffff12177fff7fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result.val[0]), 1);
         exp = UINT64_C(0x8000e79e0000ffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result.val[1]), 0);
         exp = UINT64_C(0x7fff8000e68ccfa3);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result.val[1]), 1);
         exp = UINT64_C(0x800080007fff8000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1328() {

{
   {
      int32_t arg1[8];
      int32x4x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"load2\", fnname = \"vld2q_s32\", rettype = \"int32x4x2_t\", argtypes = \"[__transfersize(8) int32_t const *]\", vals = [PtrVal [IntegerVal (-1),IntegerVal (-2147418113),IntegerVal 1091698688,IntegerVal 2147483647,IntegerVal (-32769),IntegerVal (-2088828929),IntegerVal 0,IntegerVal 2147418112]], start_saturated = False}";
      int reported = 0;
      arg1[0] = -1;
      arg1[1] = -2147418113;
      arg1[2] = 1091698688;
      arg1[3] = 2147483647;
      arg1[4] = -32769;
      arg1[5] = -2088828929;
      arg1[6] = 0;
      arg1[7] = 2147418112;
      clear_neon_saturated();
      //  Expect: "result" = 7fff0000837effff7fffffff8000ffff00000000ffff7fff41120000ffffffff
      result = vld2q_s32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result.val[0]), 0);
         exp = UINT64_C(0x41120000ffffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result.val[0]), 1);
         exp = UINT64_C(0x00000000ffff7fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result.val[1]), 0);
         exp = UINT64_C(0x7fffffff8000ffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result.val[1]), 1);
         exp = UINT64_C(0x7fff0000837effff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1329() {

{
   {
      int64_t arg1[4];
      int64x2x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"load2\", fnname = \"vld2q_s64\", rettype = \"int64x2x2_t\", argtypes = \"[__transfersize(4) int64_t const *]\", vals = [PtrVal [IntegerVal (-281473458255596),IntegerVal (-1179239412781842432),IntegerVal 1275363121623447598,IntegerVal 140739635838976]], start_saturated = False}";
      int reported = 0;
      arg1[0] = INT64_C(-281473458255596);
      arg1[1] = INT64_C(-1179239412781842432);
      arg1[2] = INT64_C(1275363121623447598);
      arg1[3] = INT64_C(140739635838976);
      clear_neon_saturated();
      //  Expect: "result" = 0000800080000000efa280007fff800011b300007fffb82effff00005a81c914
      result = vld2q_s64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result.val[0]), 0);
         exp = UINT64_C(0xffff00005a81c914);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result.val[0]), 1);
         exp = UINT64_C(0x11b300007fffb82e);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result.val[1]), 0);
         exp = UINT64_C(0xefa280007fff8000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result.val[1]), 1);
         exp = UINT64_C(0x0000800080000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1330() {

{
   {
      float32_t arg1[8];
      float32x4x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"load2\", fnname = \"vld2q_f32\", rettype = \"float32x4x2_t\", argtypes = \"[__transfersize(8) float32_t const *]\", vals = [PtrVal [FloatVal 0.11921530961990356,FloatVal 0.1744375228881836,FloatVal 0.4623566269874573,FloatVal 0.7581921815872192,FloatVal 0.6601817607879639,FloatVal 0.3729228377342224,FloatVal 0.49318569898605347,FloatVal 0.9762331247329712]], start_saturated = False}";
      int reported = 0;
      arg1[0] = ((float32_t) 0.11921530961990356);
      arg1[1] = ((float32_t) 0.1744375228881836);
      arg1[2] = ((float32_t) 0.4623566269874573);
      arg1[3] = ((float32_t) 0.7581921815872192);
      arg1[4] = ((float32_t) 0.6601817607879639);
      arg1[5] = ((float32_t) 0.3729228377342224);
      arg1[6] = ((float32_t) 0.49318569898605347);
      arg1[7] = ((float32_t) 0.9762331247329712);
      clear_neon_saturated();
      //  Expect: "result" = 3f79ea6a3ebeefbe3f4218e23e329fc03efc82d63f2901ac3eecba023df42728
      result = vld2q_f32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result.val[0], 0);
         exp = ((float32_t) 0.11921530961990356);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 0 ",
                      exp,
                      got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result.val[0], 1);
         exp = ((float32_t) 0.4623566269874573);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 1 ",
                      exp,
                      got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result.val[0], 2);
         exp = ((float32_t) 0.6601817607879639);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 2 ",
                      exp,
                      got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result.val[0], 3);
         exp = ((float32_t) 0.49318569898605347);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 3 ",
                      exp,
                      got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result.val[1], 0);
         exp = ((float32_t) 0.1744375228881836);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 0 ",
                      exp,
                      got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result.val[1], 1);
         exp = ((float32_t) 0.7581921815872192);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 1 ",
                      exp,
                      got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result.val[1], 2);
         exp = ((float32_t) 0.3729228377342224);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 2 ",
                      exp,
                      got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result.val[1], 3);
         exp = ((float32_t) 0.9762331247329712);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 3 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1331() {

{
   {
      float64_t arg1[4];
      float64x2x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"load2\", fnname = \"vld2q_f64\", rettype = \"float64x2x2_t\", argtypes = \"[__transfersize(4) float64_t const *]\", vals = [PtrVal [FloatVal 4.049748780861684e-2,FloatVal 0.18696885248611728,FloatVal 0.32137894726688343,FloatVal 0.5851577691528091]], start_saturated = False}";
      int reported = 0;
      arg1[0] = 4.049748780861684e-2;
      arg1[1] = 0.18696885248611728;
      arg1[2] = 0.32137894726688343;
      arg1[3] = 0.5851577691528091;
      clear_neon_saturated();
      //  Expect: "result" = 3fe2b99cc9305f4c3fc7ee98696635f83fd491790108964a3fa4bc16336a9500
      result = vld2q_f64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float64_t got;
         float64_t exp;
         got = vgetq_lane_f64(result.val[0], 0);
         exp = 4.049748780861684e-2;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 0 ",
                      exp,
                      got);
            }
      }
      {
         float64_t got;
         float64_t exp;
         got = vgetq_lane_f64(result.val[0], 1);
         exp = 0.32137894726688343;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 1 ",
                      exp,
                      got);
            }
      }
      {
         float64_t got;
         float64_t exp;
         got = vgetq_lane_f64(result.val[1], 0);
         exp = 0.18696885248611728;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 0 ",
                      exp,
                      got);
            }
      }
      {
         float64_t got;
         float64_t exp;
         got = vgetq_lane_f64(result.val[1], 1);
         exp = 0.5851577691528091;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 1 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1332() {

{
   {
      poly8_t arg1[32];
      poly8x16x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"load2\", fnname = \"vld2q_p8\", rettype = \"poly8x16x2_t\", argtypes = \"[__transfersize(32) poly8_t const *]\", vals = [PtrVal [PolyVal [1,0,0,0,0,1,1,0],PolyVal [0,1,0,0,0,0,1,0],PolyVal [0,1,0,0,0,0,0,0],PolyVal [0,1,0,0,0,0,1,1],PolyVal [1,0,1,0,0,1,1,0],PolyVal [0,0,1,1,0,0,1,0],PolyVal [1,1,1,0,0,1,0,1],PolyVal [0,1,0,1,0,0,0,1],PolyVal [0,0,1,1,1,0,0,1],PolyVal [0,0,0,0,1,0,1,0],PolyVal [0,0,0,1,0,1,1,1],PolyVal [1,0,0,1,1,1,0,1],PolyVal [0,0,1,0,0,0,1,1],PolyVal [0,0,1,1,0,1,1,0],PolyVal [1,0,1,1,0,0,0,1],PolyVal [1,1,1,1,0,1,1,1],PolyVal [1,1,0,0,1,1,0,0],PolyVal [0,1,1,0,1,0,0,1],PolyVal [1,0,1,0,0,0,0,0],PolyVal [1,1,0,1,0,0,0,0],PolyVal [0,1,0,1,1,0,0,0],PolyVal [0,0,0,1,0,0,0,0],PolyVal [1,0,1,1,0,1,1,1],PolyVal [0,1,1,1,0,1,0,0],PolyVal [0,1,0,0,1,1,1,0],PolyVal [1,0,0,1,0,1,1,1],PolyVal [1,1,0,1,0,0,0,1],PolyVal [1,0,0,0,0,0,0,1],PolyVal [0,1,0,0,1,1,0,0],PolyVal [0,0,1,1,1,0,1,0],PolyVal [1,0,1,0,1,0,0,0],PolyVal [0,0,0,1,0,0,0,1]]], start_saturated = False}";
      int reported = 0;
      arg1[0] = 97;
      arg1[1] = 66;
      arg1[2] = 2;
      arg1[3] = 194;
      arg1[4] = 101;
      arg1[5] = 76;
      arg1[6] = 167;
      arg1[7] = 138;
      arg1[8] = 156;
      arg1[9] = 80;
      arg1[10] = 232;
      arg1[11] = 185;
      arg1[12] = 196;
      arg1[13] = 108;
      arg1[14] = 141;
      arg1[15] = 239;
      arg1[16] = 51;
      arg1[17] = 150;
      arg1[18] = 5;
      arg1[19] = 11;
      arg1[20] = 26;
      arg1[21] = 8;
      arg1[22] = 237;
      arg1[23] = 46;
      arg1[24] = 114;
      arg1[25] = 233;
      arg1[26] = 139;
      arg1[27] = 129;
      arg1[28] = 50;
      arg1[29] = 92;
      arg1[30] = 21;
      arg1[31] = 136;
      clear_neon_saturated();
      //  Expect: "result" = 885c81e92e080b96ef6cb9508a4cc24215328b72ed1a05338dc4e89ca7650261
      result = vld2q_p8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p8(result.val[0]), 0);
         exp = UINT64_C(0x8dc4e89ca7650261);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p8(result.val[0]), 1);
         exp = UINT64_C(0x15328b72ed1a0533);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p8(result.val[1]), 0);
         exp = UINT64_C(0xef6cb9508a4cc242);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p8(result.val[1]), 1);
         exp = UINT64_C(0x885c81e92e080b96);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1333() {

{
   {
      poly16_t arg1[16];
      poly16x8x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"load2\", fnname = \"vld2q_p16\", rettype = \"poly16x8x2_t\", argtypes = \"[__transfersize(16) poly16_t const *]\", vals = [PtrVal [PolyVal [0,0,1,0,0,0,0,1,0,0,0,1,1,0,0,0],PolyVal [1,0,1,0,1,0,1,1,1,0,0,1,1,0,1,1],PolyVal [1,1,1,1,0,1,1,1,1,0,1,1,0,1,1,1],PolyVal [0,0,0,0,1,1,1,1,1,1,0,1,0,1,0,1],PolyVal [0,1,0,1,1,1,1,0,1,0,0,1,1,1,1,1],PolyVal [1,1,0,0,0,0,1,1,1,0,0,1,1,1,0,0],PolyVal [0,1,1,0,0,1,1,1,0,1,1,1,1,1,0,1],PolyVal [1,0,1,1,1,0,0,1,0,1,0,1,0,1,1,0],PolyVal [0,0,0,1,0,1,0,1,1,0,0,0,1,0,0,1],PolyVal [0,1,1,0,0,1,1,0,1,1,1,1,0,0,0,0],PolyVal [1,1,0,0,0,0,0,0,1,0,0,1,1,0,0,1],PolyVal [1,1,0,0,1,1,0,0,1,1,0,0,1,1,1,1],PolyVal [0,0,1,1,1,1,0,0,0,0,1,1,0,1,1,1],PolyVal [1,1,0,0,0,1,0,0,1,1,0,1,0,1,0,0],PolyVal [0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1],PolyVal [0,0,0,0,1,1,0,0,0,1,1,0,1,0,1,0]]], start_saturated = False}";
      int reported = 0;
      arg1[0] = 6276;
      arg1[1] = 55765;
      arg1[2] = 60911;
      arg1[3] = 44016;
      arg1[4] = 63866;
      arg1[5] = 14787;
      arg1[6] = 48870;
      arg1[7] = 27293;
      arg1[8] = 37288;
      arg1[9] = 3942;
      arg1[10] = 39171;
      arg1[11] = 62259;
      arg1[12] = 60476;
      arg1[13] = 11043;
      arg1[14] = 37378;
      arg1[15] = 22064;
      clear_neon_saturated();
      //  Expect: "result" = 56302b23f3330f666a9d39c3abf0d9d59202ec3c990391a8bee6f97aedef1884
      result = vld2q_p16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p16(result.val[0]), 0);
         exp = UINT64_C(0xbee6f97aedef1884);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p16(result.val[0]), 1);
         exp = UINT64_C(0x9202ec3c990391a8);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p16(result.val[1]), 0);
         exp = UINT64_C(0x6a9d39c3abf0d9d5);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p16(result.val[1]), 1);
         exp = UINT64_C(0x56302b23f3330f66);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1334() {
#if __ARM_NEON_FP16_INTRINSICS

{
   {
      __fp16 arg1[16];
      float16x8x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"load2\", fnname = \"vld2q_f16\", rettype = \"float16x8x2_t\", argtypes = \"[__transfersize(16) __fp16 const *]\", vals = [PtrVal [FloatVal 0.17642206956918471,FloatVal (-9.853073413858711),FloatVal 3.607080529750238,FloatVal (-0.6071884200401705),FloatVal 5.207311164359679,FloatVal 3.424585728854268e-2,FloatVal (-6.512616758934628),FloatVal 2.5582403453961966,FloatVal (-8.922278566678884),FloatVal (-4.105469416809823),FloatVal 7.770782850915328,FloatVal 0.26431104054978327,FloatVal 3.6448575887479286,FloatVal (-1.8476714836539507),FloatVal (-3.900757150027065),FloatVal (-3.0182418890554485)]], start_saturated = True}";
      int reported = 0;
      arg1[0] = 0.17642206956918471;
      arg1[1] = -9.853073413858711;
      arg1[2] = 3.607080529750238;
      arg1[3] = -0.6071884200401705;
      arg1[4] = 5.207311164359679;
      arg1[5] = 3.424585728854268e-2;
      arg1[6] = -6.512616758934628;
      arg1[7] = 2.5582403453961966;
      arg1[8] = -8.922278566678884;
      arg1[9] = -4.105469416809823;
      arg1[10] = 7.770782850915328;
      arg1[11] = 0.26431104054978327;
      arg1[12] = 3.6448575887479286;
      arg1[13] = -1.8476714836539507;
      arg1[14] = -3.900757150027065;
      arg1[15] = -3.0182418890554485;
      set_neon_saturated();
      //  Expect: "result" = c209bf64343ac41b411d2862b8dbc8edc3cd434a47c5c876c6834535433631a5
      result = vld2q_f16(arg1);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[0], 0);
         exp = 0.17642206956918471;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 0 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[0], 1);
         exp = 3.607080529750238;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 1 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[0], 2);
         exp = 5.207311164359679;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 2 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[0], 3);
         exp = -6.512616758934628;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 3 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[0], 4);
         exp = -8.922278566678884;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 4 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[0], 5);
         exp = 7.770782850915328;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 5 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[0], 6);
         exp = 3.6448575887479286;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 6 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[0], 7);
         exp = -3.900757150027065;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 7 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[1], 0);
         exp = -9.853073413858711;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 0 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[1], 1);
         exp = -0.6071884200401705;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 1 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[1], 2);
         exp = 3.424585728854268e-2;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 2 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[1], 3);
         exp = 2.5582403453961966;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 3 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[1], 4);
         exp = -4.105469416809823;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 4 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[1], 5);
         exp = 0.26431104054978327;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 5 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[1], 6);
         exp = -1.8476714836539507;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 6 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[1], 7);
         exp = -3.0182418890554485;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 7 ",
                      exp,
                      got);
            }
      }
   }
}
#endif
}
void dotests_1335() {

{
   {
      poly64_t arg1[4];
      poly64x2x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"load2\", fnname = \"vld2q_p64\", rettype = \"poly64x2x2_t\", argtypes = \"[__transfersize(4) poly64_t const *]\", vals = [PtrVal [PolyVal [0,0,0,1,0,1,0,0,0,0,0,0,1,1,0,0,1,1,0,0,1,0,1,1,0,0,1,0,1,1,1,1,1,1,1,1,0,1,1,1,0,0,0,1,0,1,1,1,0,1,0,0,1,1,1,0,0,0,1,1,0,1,0,0],PolyVal [0,1,1,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,1,1,1,0,1,1,0,1,0,1,1,0,1,0,1,1,0,0,1,1,0,1,0,0,1,0,0,0,0,1,1,1,0,0,0,1,1,0,1,1,1,0,0,1,1],PolyVal [0,0,1,1,0,1,0,0,1,1,0,1,0,0,0,1,1,0,1,0,1,0,1,1,1,0,0,0,1,0,0,1,1,1,1,1,1,0,0,1,1,0,0,0,1,0,1,0,0,1,0,0,0,1,1,0,0,0,0,0,0,1,0,0],PolyVal [1,1,1,0,0,1,0,1,1,0,1,0,0,0,1,0,0,1,1,0,0,1,1,1,0,0,0,0,1,1,1,1,1,0,1,0,0,1,1,0,1,0,1,0,1,0,1,0,0,1,0,1,1,0,0,0,1,0,0,1,1,0,1,1]]], start_saturated = False}";
      int reported = 0;
      arg1[0] = 3202878402316152872;
      arg1[1] = -3546855844790906362;
      arg1[2] = 2333517302719679276;
      arg1[3] = -2802833921763031641;
      clear_neon_saturated();
      //  Expect: "result" = d91a5565f0e645a7cec70966b5b852062062519f91d58b2c2c72e8eff4d33028
      result = vld2q_p64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p64(result.val[0]), 0);
         exp = UINT64_C(0x2c72e8eff4d33028);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p64(result.val[0]), 1);
         exp = UINT64_C(0x2062519f91d58b2c);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p64(result.val[1]), 0);
         exp = UINT64_C(0xcec70966b5b85206);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p64(result.val[1]), 1);
         exp = UINT64_C(0xd91a5565f0e645a7);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1336() {

{
   {
      uint8_t arg1[16];
      uint8x8x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"load2\", fnname = \"vld2_u8\", rettype = \"uint8x8x2_t\", argtypes = \"[__transfersize(16) uint8_t const *]\", vals = [PtrVal [IntegerVal 39,IntegerVal 128,IntegerVal 0,IntegerVal 127,IntegerVal 255,IntegerVal 128,IntegerVal 205,IntegerVal 185,IntegerVal 127,IntegerVal 199,IntegerVal 255,IntegerVal 255,IntegerVal 57,IntegerVal 127,IntegerVal 98,IntegerVal 23]], start_saturated = False}";
      int reported = 0;
      arg1[0] = 39U;
      arg1[1] = 128U;
      arg1[2] = 0;
      arg1[3] = 127U;
      arg1[4] = 255U;
      arg1[5] = 128U;
      arg1[6] = 205U;
      arg1[7] = 185U;
      arg1[8] = 127U;
      arg1[9] = 199U;
      arg1[10] = 255U;
      arg1[11] = 255U;
      arg1[12] = 57U;
      arg1[13] = 127U;
      arg1[14] = 98U;
      arg1[15] = 23U;
      clear_neon_saturated();
      //  Expect: "result" = 177fffc7b9807f806239ff7fcdff0027
      result = vld2_u8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_u8(result.val[0]), 0);
         exp = UINT64_C(0x6239ff7fcdff0027);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_u8(result.val[1]), 0);
         exp = UINT64_C(0x177fffc7b9807f80);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1337() {

{
   {
      uint16_t arg1[8];
      uint16x4x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"load2\", fnname = \"vld2_u16\", rettype = \"uint16x4x2_t\", argtypes = \"[__transfersize(8) uint16_t const *]\", vals = [PtrVal [IntegerVal 32767,IntegerVal 32768,IntegerVal 6423,IntegerVal 33837,IntegerVal 32767,IntegerVal 0,IntegerVal 0,IntegerVal 65535]], start_saturated = False}";
      int reported = 0;
      arg1[0] = 32767U;
      arg1[1] = 32768U;
      arg1[2] = 6423U;
      arg1[3] = 33837U;
      arg1[4] = 32767U;
      arg1[5] = 0;
      arg1[6] = 0;
      arg1[7] = 65535U;
      clear_neon_saturated();
      //  Expect: "result" = ffff0000842d800000007fff19177fff
      result = vld2_u16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_u16(result.val[0]), 0);
         exp = UINT64_C(0x00007fff19177fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_u16(result.val[1]), 0);
         exp = UINT64_C(0xffff0000842d8000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1338() {

{
   {
      uint32_t arg1[4];
      uint32x2x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"load2\", fnname = \"vld2_u32\", rettype = \"uint32x2x2_t\", argtypes = \"[__transfersize(4) uint32_t const *]\", vals = [PtrVal [IntegerVal 2147418112,IntegerVal 2850848768,IntegerVal 65535,IntegerVal 4294935911]], start_saturated = False}";
      int reported = 0;
      arg1[0] = 2147418112U;
      arg1[1] = 2850848768U;
      arg1[2] = 65535U;
      arg1[3] = 4294935911U;
      clear_neon_saturated();
      //  Expect: "result" = ffff8567a9ec80000000ffff7fff0000
      result = vld2_u32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_u32(result.val[0]), 0);
         exp = UINT64_C(0x0000ffff7fff0000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_u32(result.val[1]), 0);
         exp = UINT64_C(0xffff8567a9ec8000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1339() {

{
   {
      uint64_t arg1[2];
      uint64x1x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"load2\", fnname = \"vld2_u64\", rettype = \"uint64x1x2_t\", argtypes = \"[__transfersize(2) uint64_t const *]\", vals = [PtrVal [IntegerVal 9223231297218936831,IntegerVal 9223090564025547461]], start_saturated = False}";
      int reported = 0;
      arg1[0] = UINT64_C(0x7fff7fff7fffffff);
      arg1[1] = UINT64_C(0x7fff00007ffffac5);
      clear_neon_saturated();
      //  Expect: "result" = 7fff00007ffffac57fff7fff7fffffff
      result = vld2_u64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(result.val[0], 0);
         exp = UINT64_C(0x7fff7fff7fffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(result.val[1], 0);
         exp = UINT64_C(0x7fff00007ffffac5);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1340() {

{
   {
      int8_t arg1[16];
      int8x8x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"load2\", fnname = \"vld2_s8\", rettype = \"int8x8x2_t\", argtypes = \"[__transfersize(16) int8_t const *]\", vals = [PtrVal [IntegerVal 0,IntegerVal (-1),IntegerVal 0,IntegerVal (-70),IntegerVal (-1),IntegerVal (-1),IntegerVal (-128),IntegerVal (-1),IntegerVal 127,IntegerVal 0,IntegerVal (-1),IntegerVal 127,IntegerVal 127,IntegerVal (-1),IntegerVal 0,IntegerVal 127]], start_saturated = False}";
      int reported = 0;
      arg1[0] = 0;
      arg1[1] = -1;
      arg1[2] = 0;
      arg1[3] = -70;
      arg1[4] = -1;
      arg1[5] = -1;
      arg1[6] = -128;
      arg1[7] = -1;
      arg1[8] = 127;
      arg1[9] = 0;
      arg1[10] = -1;
      arg1[11] = 127;
      arg1[12] = 127;
      arg1[13] = -1;
      arg1[14] = 0;
      arg1[15] = 127;
      clear_neon_saturated();
      //  Expect: "result" = 7fff7f00ffffbaff007fff7f80ff0000
      result = vld2_s8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_s8(result.val[0]), 0);
         exp = UINT64_C(0x007fff7f80ff0000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_s8(result.val[1]), 0);
         exp = UINT64_C(0x7fff7f00ffffbaff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1341() {

{
   {
      int16_t arg1[8];
      int16x4x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"load2\", fnname = \"vld2_s16\", rettype = \"int16x4x2_t\", argtypes = \"[__transfersize(8) int16_t const *]\", vals = [PtrVal [IntegerVal (-32768),IntegerVal 0,IntegerVal 32767,IntegerVal 0,IntegerVal 32767,IntegerVal 0,IntegerVal (-1),IntegerVal 15167]], start_saturated = False}";
      int reported = 0;
      arg1[0] = -32768;
      arg1[1] = 0;
      arg1[2] = 32767;
      arg1[3] = 0;
      arg1[4] = 32767;
      arg1[5] = 0;
      arg1[6] = -1;
      arg1[7] = 15167;
      clear_neon_saturated();
      //  Expect: "result" = 3b3f000000000000ffff7fff7fff8000
      result = vld2_s16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_s16(result.val[0]), 0);
         exp = UINT64_C(0xffff7fff7fff8000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_s16(result.val[1]), 0);
         exp = UINT64_C(0x3b3f000000000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1342() {

{
   {
      int32_t arg1[4];
      int32x2x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"load2\", fnname = \"vld2_s32\", rettype = \"int32x2x2_t\", argtypes = \"[__transfersize(4) int32_t const *]\", vals = [PtrVal [IntegerVal 56998,IntegerVal (-2147483648),IntegerVal (-32769),IntegerVal (-1976401920)]], start_saturated = False}";
      int reported = 0;
      arg1[0] = 56998;
      arg1[1] = (int32_t) 0x80000000;
      arg1[2] = -32769;
      arg1[3] = -1976401920;
      clear_neon_saturated();
      //  Expect: "result" = 8a32800080000000ffff7fff0000dea6
      result = vld2_s32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_s32(result.val[0]), 0);
         exp = UINT64_C(0xffff7fff0000dea6);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_s32(result.val[1]), 0);
         exp = UINT64_C(0x8a32800080000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1343() {

{
   {
      int64_t arg1[2];
      int64x1x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"load2\", fnname = \"vld2_s64\", rettype = \"int64x1x2_t\", argtypes = \"[__transfersize(2) int64_t const *]\", vals = [PtrVal [IntegerVal (-1639940097),IntegerVal (-9223090564025614336)]], start_saturated = False}";
      int reported = 0;
      arg1[0] = INT64_C(-1639940097);
      arg1[1] = INT64_C(-9223090564025614336);
      clear_neon_saturated();
      //  Expect: "result" = 8000ffff7fff0000ffffffff9e407fff
      result = vld2_s64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_s64(result.val[0]), 0);
         exp = UINT64_C(0xffffffff9e407fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_s64(result.val[1]), 0);
         exp = UINT64_C(0x8000ffff7fff0000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1344() {

{
   {
      float32_t arg1[4];
      float32x2x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"load2\", fnname = \"vld2_f32\", rettype = \"float32x2x2_t\", argtypes = \"[__transfersize(4) float32_t const *]\", vals = [PtrVal [FloatVal 0.5258432030677795,FloatVal 0.6391112208366394,FloatVal 0.5386337637901306,FloatVal 0.5084552764892578]], start_saturated = False}";
      int reported = 0;
      arg1[0] = ((float32_t) 0.5258432030677795);
      arg1[1] = ((float32_t) 0.6391112208366394);
      arg1[2] = ((float32_t) 0.5386337637901306);
      arg1[3] = ((float32_t) 0.5084552764892578);
      clear_neon_saturated();
      //  Expect: "result" = 3f022a203f239ccb3f09e3e73f069da9
      result = vld2_f32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result.val[0], 0);
         exp = ((float32_t) 0.5258432030677795);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 0 ",
                      exp,
                      got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result.val[0], 1);
         exp = ((float32_t) 0.5386337637901306);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 1 ",
                      exp,
                      got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result.val[1], 0);
         exp = ((float32_t) 0.6391112208366394);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 0 ",
                      exp,
                      got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result.val[1], 1);
         exp = ((float32_t) 0.5084552764892578);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 1 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1345() {

{
   {
      float64_t arg1[2];
      float64x1x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"load2\", fnname = \"vld2_f64\", rettype = \"float64x1x2_t\", argtypes = \"[__transfersize(2) float64_t const *]\", vals = [PtrVal [FloatVal 0.16016646989988048,FloatVal 0.38000349022654356]], start_saturated = False}";
      int reported = 0;
      arg1[0] = 0.16016646989988048;
      arg1[1] = 0.38000349022654356;
      clear_neon_saturated();
      //  Expect: "result" = 3fd851fa28b8e3163fc48055bb11606c
      result = vld2_f64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float64_t got;
         float64_t exp;
         got = vget_lane_f64(result.val[0], 0);
         exp = 0.16016646989988048;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 0 ",
                      exp,
                      got);
            }
      }
      {
         float64_t got;
         float64_t exp;
         got = vget_lane_f64(result.val[1], 0);
         exp = 0.38000349022654356;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 0 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1346() {

{
   {
      poly8_t arg1[16];
      poly8x8x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"load2\", fnname = \"vld2_p8\", rettype = \"poly8x8x2_t\", argtypes = \"[__transfersize(16) poly8_t const *]\", vals = [PtrVal [PolyVal [0,0,1,0,1,0,1,1],PolyVal [0,1,1,1,1,0,0,0],PolyVal [1,0,0,0,1,1,0,1],PolyVal [0,0,1,0,1,1,0,0],PolyVal [0,1,0,1,0,1,1,0],PolyVal [0,0,0,1,0,1,1,1],PolyVal [1,1,0,1,0,1,0,1],PolyVal [0,0,1,1,1,1,1,0],PolyVal [1,0,0,0,1,0,1,1],PolyVal [1,1,0,0,1,1,1,0],PolyVal [1,1,0,0,0,1,1,0],PolyVal [1,0,0,1,0,1,0,1],PolyVal [1,1,1,0,1,1,0,1],PolyVal [1,1,1,1,1,1,1,0],PolyVal [0,1,1,1,1,0,1,1],PolyVal [0,1,0,1,1,1,1,1]]], start_saturated = False}";
      int reported = 0;
      arg1[0] = 212;
      arg1[1] = 30;
      arg1[2] = 177;
      arg1[3] = 52;
      arg1[4] = 106;
      arg1[5] = 232;
      arg1[6] = 171;
      arg1[7] = 124;
      arg1[8] = 209;
      arg1[9] = 115;
      arg1[10] = 99;
      arg1[11] = 169;
      arg1[12] = 183;
      arg1[13] = 127;
      arg1[14] = 222;
      arg1[15] = 250;
      clear_neon_saturated();
      //  Expect: "result" = fa7fa9737ce8341edeb763d1ab6ab1d4
      result = vld2_p8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_p8(result.val[0]), 0);
         exp = UINT64_C(0xdeb763d1ab6ab1d4);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_p8(result.val[1]), 0);
         exp = UINT64_C(0xfa7fa9737ce8341e);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1347() {

{
   {
      poly16_t arg1[8];
      poly16x4x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"load2\", fnname = \"vld2_p16\", rettype = \"poly16x4x2_t\", argtypes = \"[__transfersize(8) poly16_t const *]\", vals = [PtrVal [PolyVal [0,1,1,0,1,0,1,0,0,1,1,1,0,0,1,0],PolyVal [0,1,0,0,1,0,0,0,1,0,0,1,0,0,0,0],PolyVal [1,0,0,1,0,0,0,1,0,1,1,0,1,0,0,1],PolyVal [1,0,0,1,0,0,1,1,0,1,0,1,1,1,1,0],PolyVal [0,0,0,1,1,0,0,1,0,0,1,1,1,0,1,1],PolyVal [0,1,0,1,1,0,0,1,1,0,1,0,1,0,1,0],PolyVal [0,1,0,0,0,1,0,1,1,0,0,1,0,0,1,0],PolyVal [0,0,0,0,0,1,1,1,1,1,0,0,1,1,1,0]]], start_saturated = False}";
      int reported = 0;
      arg1[0] = 20054;
      arg1[1] = 2322;
      arg1[2] = 38537;
      arg1[3] = 31433;
      arg1[4] = 56472;
      arg1[5] = 21914;
      arg1[6] = 18850;
      arg1[7] = 29664;
      clear_neon_saturated();
      //  Expect: "result" = 73e0559a7ac9091249a2dc9896894e56
      result = vld2_p16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_p16(result.val[0]), 0);
         exp = UINT64_C(0x49a2dc9896894e56);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_p16(result.val[1]), 0);
         exp = UINT64_C(0x73e0559a7ac90912);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1348() {
#if __ARM_NEON_FP16_INTRINSICS

{
   {
      __fp16 arg1[8];
      float16x4x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"load2\", fnname = \"vld2_f16\", rettype = \"float16x4x2_t\", argtypes = \"[__transfersize(8) __fp16 const *]\", vals = [PtrVal [FloatVal 4.963435085031907,FloatVal 6.855832790017708,FloatVal 3.388984321854373,FloatVal 6.5787385765823885,FloatVal (-5.177766140531254),FloatVal (-2.4666338767100315),FloatVal 0.6609631336337696,FloatVal 9.236961927557598]], start_saturated = False}";
      int reported = 0;
      arg1[0] = 4.963435085031907;
      arg1[1] = 6.855832790017708;
      arg1[2] = 3.388984321854373;
      arg1[3] = 6.5787385765823885;
      arg1[4] = -5.177766140531254;
      arg1[5] = -2.4666338767100315;
      arg1[6] = 0.6609631336337696;
      arg1[7] = 9.236961927557598;
      clear_neon_saturated();
      //  Expect: "result" = 489ec0ee469446db3949c52d42c744f6
      result = vld2_f16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         __fp16 got;
         __fp16 exp;
         got = vget_lane_f16(result.val[0], 0);
         exp = 4.963435085031907;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 0 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vget_lane_f16(result.val[0], 1);
         exp = 3.388984321854373;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 1 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vget_lane_f16(result.val[0], 2);
         exp = -5.177766140531254;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 2 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vget_lane_f16(result.val[0], 3);
         exp = 0.6609631336337696;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 3 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vget_lane_f16(result.val[1], 0);
         exp = 6.855832790017708;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 0 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vget_lane_f16(result.val[1], 1);
         exp = 6.5787385765823885;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 1 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vget_lane_f16(result.val[1], 2);
         exp = -2.4666338767100315;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 2 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vget_lane_f16(result.val[1], 3);
         exp = 9.236961927557598;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 3 ",
                      exp,
                      got);
            }
      }
   }
}
#endif
}
void dotests_1349() {

{
   {
      poly64_t arg1[2];
      poly64x1x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"load2\", fnname = \"vld2_p64\", rettype = \"poly64x1x2_t\", argtypes = \"[__transfersize(2) poly64_t const *]\", vals = [PtrVal [PolyVal [1,1,1,1,0,1,1,0,1,1,0,1,1,1,1,1,0,1,0,1,1,0,1,0,1,1,1,1,1,0,1,1,0,0,1,0,1,1,0,1,1,0,1,0,0,1,0,0,0,1,1,1,0,0,1,0,0,1,0,1,1,1,0,1],PolyVal [0,0,0,0,1,0,1,1,0,1,1,0,1,1,0,0,1,0,1,0,1,1,0,0,0,1,0,0,1,0,0,1,1,0,0,1,1,1,1,1,0,1,0,0,1,1,1,0,0,1,0,1,0,0,0,1,0,1,1,0,0,1,0,0]]], start_saturated = False}";
      int reported = 0;
      arg1[0] = -5022035075699901585;
      arg1[1] = 2777158536452716240;
      clear_neon_saturated();
      //  Expect: "result" = 268a72f9923536d0ba4e25b4df5afb6f
      result = vld2_p64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_p64(result.val[0]), 0);
         exp = UINT64_C(0xba4e25b4df5afb6f);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_p64(result.val[1]), 0);
         exp = UINT64_C(0x268a72f9923536d0);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1350() {

{
   {
      uint8_t arg1[48];
      uint8x16x3_t result;
      char* str1 = "ReproInfo2 {semantics = \"load3\", fnname = \"vld3q_u8\", rettype = \"uint8x16x3_t\", argtypes = \"[__transfersize(48) uint8_t const *]\", vals = [PtrVal [IntegerVal 127,IntegerVal 255,IntegerVal 160,IntegerVal 127,IntegerVal 128,IntegerVal 128,IntegerVal 127,IntegerVal 0,IntegerVal 255,IntegerVal 128,IntegerVal 127,IntegerVal 127,IntegerVal 220,IntegerVal 127,IntegerVal 255,IntegerVal 0,IntegerVal 0,IntegerVal 139,IntegerVal 255,IntegerVal 255,IntegerVal 146,IntegerVal 127,IntegerVal 128,IntegerVal 128,IntegerVal 119,IntegerVal 128,IntegerVal 127,IntegerVal 0,IntegerVal 0,IntegerVal 255,IntegerVal 25,IntegerVal 128,IntegerVal 37,IntegerVal 255,IntegerVal 128,IntegerVal 124,IntegerVal 255,IntegerVal 255,IntegerVal 255,IntegerVal 104,IntegerVal 0,IntegerVal 127,IntegerVal 255,IntegerVal 0,IntegerVal 210,IntegerVal 127,IntegerVal 36,IntegerVal 255]], start_saturated = False}";
      int reported = 0;
      arg1[0] = 127U;
      arg1[1] = 255U;
      arg1[2] = 160U;
      arg1[3] = 127U;
      arg1[4] = 128U;
      arg1[5] = 128U;
      arg1[6] = 127U;
      arg1[7] = 0;
      arg1[8] = 255U;
      arg1[9] = 128U;
      arg1[10] = 127U;
      arg1[11] = 127U;
      arg1[12] = 220U;
      arg1[13] = 127U;
      arg1[14] = 255U;
      arg1[15] = 0;
      arg1[16] = 0;
      arg1[17] = 139U;
      arg1[18] = 255U;
      arg1[19] = 255U;
      arg1[20] = 146U;
      arg1[21] = 127U;
      arg1[22] = 128U;
      arg1[23] = 128U;
      arg1[24] = 119U;
      arg1[25] = 128U;
      arg1[26] = 127U;
      arg1[27] = 0;
      arg1[28] = 0;
      arg1[29] = 255U;
      arg1[30] = 25U;
      arg1[31] = 128U;
      arg1[32] = 37U;
      arg1[33] = 255U;
      arg1[34] = 128U;
      arg1[35] = 124U;
      arg1[36] = 255U;
      arg1[37] = 255U;
      arg1[38] = 255U;
      arg1[39] = 104U;
      arg1[40] = 0;
      arg1[41] = 127U;
      arg1[42] = 255U;
      arg1[43] = 0;
      arg1[44] = 210U;
      arg1[45] = 127U;
      arg1[46] = 36U;
      arg1[47] = 255U;
      clear_neon_saturated();
      //  Expect: "result" = ffd27fff7c25ff7f80928bff7fff80a0240000ff8080008080ff007f7f0080ff7fff68ffff1900777fff00dc807f7f7f
      result = vld3q_u8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result.val[0]), 0);
         exp = UINT64_C(0x7fff00dc807f7f7f);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result.val[0]), 1);
         exp = UINT64_C(0x7fff68ffff190077);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result.val[1]), 0);
         exp = UINT64_C(0x80ff007f7f0080ff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result.val[1]), 1);
         exp = UINT64_C(0x240000ff80800080);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result.val[2]), 0);
         exp = UINT64_C(0x80928bff7fff80a0);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result.val[2]), 1);
         exp = UINT64_C(0xffd27fff7c25ff7f);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1351() {

{
   {
      uint16_t arg1[24];
      uint16x8x3_t result;
      char* str1 = "ReproInfo2 {semantics = \"load3\", fnname = \"vld3q_u16\", rettype = \"uint16x8x3_t\", argtypes = \"[__transfersize(24) uint16_t const *]\", vals = [PtrVal [IntegerVal 32767,IntegerVal 1168,IntegerVal 65535,IntegerVal 65535,IntegerVal 0,IntegerVal 32768,IntegerVal 65535,IntegerVal 32767,IntegerVal 32768,IntegerVal 32768,IntegerVal 64222,IntegerVal 32767,IntegerVal 32768,IntegerVal 32767,IntegerVal 65535,IntegerVal 24693,IntegerVal 61481,IntegerVal 32768,IntegerVal 65535,IntegerVal 32768,IntegerVal 32768,IntegerVal 0,IntegerVal 0,IntegerVal 32768]], start_saturated = False}";
      int reported = 0;
      arg1[0] = 32767U;
      arg1[1] = 1168U;
      arg1[2] = 65535U;
      arg1[3] = 65535U;
      arg1[4] = 0;
      arg1[5] = 32768U;
      arg1[6] = 65535U;
      arg1[7] = 32767U;
      arg1[8] = 32768U;
      arg1[9] = 32768U;
      arg1[10] = 64222U;
      arg1[11] = 32767U;
      arg1[12] = 32768U;
      arg1[13] = 32767U;
      arg1[14] = 65535U;
      arg1[15] = 24693U;
      arg1[16] = 61481U;
      arg1[17] = 32768U;
      arg1[18] = 65535U;
      arg1[19] = 32768U;
      arg1[20] = 32768U;
      arg1[21] = 0;
      arg1[22] = 0;
      arg1[23] = 32768U;
      clear_neon_saturated();
      //  Expect: "result" = 800080008000ffff7fff80008000ffff00008000f0297ffffade7fff000004900000ffff607580008000ffffffff7fff
      result = vld3q_u16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result.val[0]), 0);
         exp = UINT64_C(0x8000ffffffff7fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result.val[0]), 1);
         exp = UINT64_C(0x0000ffff60758000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result.val[1]), 0);
         exp = UINT64_C(0xfade7fff00000490);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result.val[1]), 1);
         exp = UINT64_C(0x00008000f0297fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result.val[2]), 0);
         exp = UINT64_C(0x7fff80008000ffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result.val[2]), 1);
         exp = UINT64_C(0x800080008000ffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1352() {

{
   {
      uint32_t arg1[12];
      uint32x4x3_t result;
      char* str1 = "ReproInfo2 {semantics = \"load3\", fnname = \"vld3q_u32\", rettype = \"uint32x4x3_t\", argtypes = \"[__transfersize(12) uint32_t const *]\", vals = [PtrVal [IntegerVal 2147446495,IntegerVal 4277403648,IntegerVal 2147483647,IntegerVal 2147450880,IntegerVal 2147549183,IntegerVal 2147549183,IntegerVal 2147450879,IntegerVal 4294967295,IntegerVal 4294967295,IntegerVal 2147504992,IntegerVal 4294934527,IntegerVal 4784128]], start_saturated = False}";
      int reported = 0;
      arg1[0] = 2147446495U;
      arg1[1] = 4277403648U;
      arg1[2] = 2147483647U;
      arg1[3] = 2147450880U;
      arg1[4] = 2147549183U;
      arg1[5] = 2147549183U;
      arg1[6] = 2147450879U;
      arg1[7] = 4294967295U;
      arg1[8] = 4294967295U;
      arg1[9] = 2147504992U;
      arg1[10] = 4294934527U;
      arg1[11] = 4784128U;
      clear_neon_saturated();
      //  Expect: "result" = 00490000ffffffff8000ffff7fffffffffff7fffffffffff8000fffffef40000800053607fff7fff7fff80007fff6edf
      result = vld3q_u32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result.val[0]), 0);
         exp = UINT64_C(0x7fff80007fff6edf);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result.val[0]), 1);
         exp = UINT64_C(0x800053607fff7fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result.val[1]), 0);
         exp = UINT64_C(0x8000fffffef40000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result.val[1]), 1);
         exp = UINT64_C(0xffff7fffffffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result.val[2]), 0);
         exp = UINT64_C(0x8000ffff7fffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result.val[2]), 1);
         exp = UINT64_C(0x00490000ffffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1353() {

{
   {
      uint64_t arg1[6];
      uint64x2x3_t result;
      char* str1 = "ReproInfo2 {semantics = \"load3\", fnname = \"vld3q_u64\", rettype = \"uint64x2x3_t\", argtypes = \"[__transfersize(6) uint64_t const *]\", vals = [PtrVal [IntegerVal 140741783289856,IntegerVal 9223372036854743040,IntegerVal 9223090564025581568,IntegerVal 6188790312937164107,IntegerVal 10863526726147735551,IntegerVal 9223090564025581568]], start_saturated = False}";
      int reported = 0;
      arg1[0] = UINT64_C(0x00008000ffff8000);
      arg1[1] = UINT64_C(0x7fffffffffff8000);
      arg1[2] = UINT64_C(0x7fff000080008000);
      arg1[3] = UINT64_C(0x55e2ffffffff8d4b);
      arg1[4] = UINT64_C(0x96c2ffffffff7fff);
      arg1[5] = UINT64_C(0x7fff000080008000);
      clear_neon_saturated();
      //  Expect: "result" = 7fff0000800080007fff00008000800096c2ffffffff7fff7fffffffffff800055e2ffffffff8d4b00008000ffff8000
      result = vld3q_u64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result.val[0], 0);
         exp = UINT64_C(0x00008000ffff8000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result.val[0], 1);
         exp = UINT64_C(0x55e2ffffffff8d4b);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result.val[1], 0);
         exp = UINT64_C(0x7fffffffffff8000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result.val[1], 1);
         exp = UINT64_C(0x96c2ffffffff7fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result.val[2], 0);
         exp = UINT64_C(0x7fff000080008000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result.val[2], 1);
         exp = UINT64_C(0x7fff000080008000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1354() {

{
   {
      int8_t arg1[48];
      int8x16x3_t result;
      char* str1 = "ReproInfo2 {semantics = \"load3\", fnname = \"vld3q_s8\", rettype = \"int8x16x3_t\", argtypes = \"[__transfersize(48) int8_t const *]\", vals = [PtrVal [IntegerVal 0,IntegerVal 0,IntegerVal 127,IntegerVal 0,IntegerVal (-128),IntegerVal (-108),IntegerVal 0,IntegerVal 0,IntegerVal (-128),IntegerVal 75,IntegerVal 0,IntegerVal 127,IntegerVal (-16),IntegerVal 127,IntegerVal 0,IntegerVal 127,IntegerVal (-1),IntegerVal (-128),IntegerVal 0,IntegerVal 127,IntegerVal (-35),IntegerVal (-128),IntegerVal 124,IntegerVal 0,IntegerVal (-128),IntegerVal (-1),IntegerVal 127,IntegerVal 127,IntegerVal (-128),IntegerVal (-1),IntegerVal (-128),IntegerVal 0,IntegerVal 10,IntegerVal (-128),IntegerVal 0,IntegerVal (-1),IntegerVal (-1),IntegerVal (-128),IntegerVal 0,IntegerVal 0,IntegerVal (-53),IntegerVal 127,IntegerVal (-128),IntegerVal (-1),IntegerVal 105,IntegerVal (-1),IntegerVal (-1),IntegerVal (-128)]], start_saturated = False}";
      int reported = 0;
      arg1[0] = 0;
      arg1[1] = 0;
      arg1[2] = 127;
      arg1[3] = 0;
      arg1[4] = -128;
      arg1[5] = -108;
      arg1[6] = 0;
      arg1[7] = 0;
      arg1[8] = -128;
      arg1[9] = 75;
      arg1[10] = 0;
      arg1[11] = 127;
      arg1[12] = -16;
      arg1[13] = 127;
      arg1[14] = 0;
      arg1[15] = 127;
      arg1[16] = -1;
      arg1[17] = -128;
      arg1[18] = 0;
      arg1[19] = 127;
      arg1[20] = -35;
      arg1[21] = -128;
      arg1[22] = 124;
      arg1[23] = 0;
      arg1[24] = -128;
      arg1[25] = -1;
      arg1[26] = 127;
      arg1[27] = 127;
      arg1[28] = -128;
      arg1[29] = -1;
      arg1[30] = -128;
      arg1[31] = 0;
      arg1[32] = 10;
      arg1[33] = -128;
      arg1[34] = 0;
      arg1[35] = -1;
      arg1[36] = -1;
      arg1[37] = -128;
      arg1[38] = 0;
      arg1[39] = 0;
      arg1[40] = -53;
      arg1[41] = 127;
      arg1[42] = -128;
      arg1[43] = -1;
      arg1[44] = 105;
      arg1[45] = -1;
      arg1[46] = -1;
      arg1[47] = -128;
      clear_neon_saturated();
      //  Expect: "result" = 80697f00ff0aff7f00dd80007f80947fffffcb80000080ff7c7fff7f00008000ff8000ff80807f8080007ff04b000000
      result = vld3q_s8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result.val[0]), 0);
         exp = UINT64_C(0x80007ff04b000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result.val[0]), 1);
         exp = UINT64_C(0xff8000ff80807f80);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result.val[1]), 0);
         exp = UINT64_C(0x7c7fff7f00008000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result.val[1]), 1);
         exp = UINT64_C(0xffffcb80000080ff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result.val[2]), 0);
         exp = UINT64_C(0x00dd80007f80947f);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result.val[2]), 1);
         exp = UINT64_C(0x80697f00ff0aff7f);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1355() {

{
   {
      int16_t arg1[24];
      int16x8x3_t result;
      char* str1 = "ReproInfo2 {semantics = \"load3\", fnname = \"vld3q_s16\", rettype = \"int16x8x3_t\", argtypes = \"[__transfersize(24) int16_t const *]\", vals = [PtrVal [IntegerVal (-32768),IntegerVal 0,IntegerVal (-32768),IntegerVal 21725,IntegerVal (-32768),IntegerVal (-1),IntegerVal 32767,IntegerVal (-1),IntegerVal (-32768),IntegerVal (-32768),IntegerVal (-1),IntegerVal (-32768),IntegerVal (-32768),IntegerVal (-1),IntegerVal 0,IntegerVal 0,IntegerVal 28892,IntegerVal (-1),IntegerVal 0,IntegerVal 32767,IntegerVal (-32768),IntegerVal (-1),IntegerVal 0,IntegerVal (-27432)]], start_saturated = False}";
      int reported = 0;
      arg1[0] = -32768;
      arg1[1] = 0;
      arg1[2] = -32768;
      arg1[3] = 21725;
      arg1[4] = -32768;
      arg1[5] = -1;
      arg1[6] = 32767;
      arg1[7] = -1;
      arg1[8] = -32768;
      arg1[9] = -32768;
      arg1[10] = -1;
      arg1[11] = -32768;
      arg1[12] = -32768;
      arg1[13] = -1;
      arg1[14] = 0;
      arg1[15] = 0;
      arg1[16] = 28892;
      arg1[17] = -1;
      arg1[18] = 0;
      arg1[19] = 32767;
      arg1[20] = -32768;
      arg1[21] = -1;
      arg1[22] = 0;
      arg1[23] = -27432;
      clear_neon_saturated();
      //  Expect: "result" = 94d88000ffff000080008000ffff800000007fff70dcffffffffffff80000000ffff00000000800080007fff54dd8000
      result = vld3q_s16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result.val[0]), 0);
         exp = UINT64_C(0x80007fff54dd8000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result.val[0]), 1);
         exp = UINT64_C(0xffff000000008000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result.val[1]), 0);
         exp = UINT64_C(0xffffffff80000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result.val[1]), 1);
         exp = UINT64_C(0x00007fff70dcffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result.val[2]), 0);
         exp = UINT64_C(0x80008000ffff8000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result.val[2]), 1);
         exp = UINT64_C(0x94d88000ffff0000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1356() {

{
   {
      int32_t arg1[12];
      int32x4x3_t result;
      char* str1 = "ReproInfo2 {semantics = \"load3\", fnname = \"vld3q_s32\", rettype = \"int32x4x3_t\", argtypes = \"[__transfersize(12) int32_t const *]\", vals = [PtrVal [IntegerVal 2147464164,IntegerVal 110428159,IntegerVal 0,IntegerVal 2147450879,IntegerVal 65535,IntegerVal (-1316487169),IntegerVal (-2147478185),IntegerVal 2147450879,IntegerVal (-1),IntegerVal 760905727,IntegerVal (-2147483648),IntegerVal 32767]], start_saturated = False}";
      int reported = 0;
      arg1[0] = 2147464164;
      arg1[1] = 110428159;
      arg1[2] = 0;
      arg1[3] = 2147450879;
      arg1[4] = 65535;
      arg1[5] = -1316487169;
      arg1[6] = -2147478185;
      arg1[7] = 2147450879;
      arg1[8] = -1;
      arg1[9] = 760905727;
      arg1[10] = (int32_t) 0x80000000;
      arg1[11] = 32767;
      clear_neon_saturated();
      //  Expect: "result" = 00007fffffffffffb187ffff00000000800000007fff7fff0000ffff0694ffff2d5a7fff800015577fff7fff7fffb3e4
      result = vld3q_s32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result.val[0]), 0);
         exp = UINT64_C(0x7fff7fff7fffb3e4);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result.val[0]), 1);
         exp = UINT64_C(0x2d5a7fff80001557);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result.val[1]), 0);
         exp = UINT64_C(0x0000ffff0694ffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result.val[1]), 1);
         exp = UINT64_C(0x800000007fff7fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result.val[2]), 0);
         exp = UINT64_C(0xb187ffff00000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result.val[2]), 1);
         exp = UINT64_C(0x00007fffffffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1357() {

{
   {
      int64_t arg1[6];
      int64x2x3_t result;
      char* str1 = "ReproInfo2 {semantics = \"load3\", fnname = \"vld3q_s64\", rettype = \"int64x2x3_t\", argtypes = \"[__transfersize(6) int64_t const *]\", vals = [PtrVal [IntegerVal 281470681776127,IntegerVal (-140739635871744),IntegerVal 9223231301513969663,IntegerVal (-9223372036854743040),IntegerVal (-140739635904512),IntegerVal 140739635904511]], start_saturated = False}";
      int reported = 0;
      arg1[0] = INT64_C(281470681776127);
      arg1[1] = INT64_C(-140739635871744);
      arg1[2] = INT64_C(9223231301513969663);
      arg1[3] = INT64_C(-9223372036854743040);
      arg1[4] = INT64_C(-140739635904512);
      arg1[5] = INT64_C(140739635904511);
      clear_neon_saturated();
      //  Expect: "result" = 000080008000ffff7fff80008000ffffffff7fff7fff0000ffff7fff7fff800080000000000080000000ffff00007fff
      result = vld3q_s64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result.val[0]), 0);
         exp = UINT64_C(0x0000ffff00007fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result.val[0]), 1);
         exp = UINT64_C(0x8000000000008000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result.val[1]), 0);
         exp = UINT64_C(0xffff7fff7fff8000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result.val[1]), 1);
         exp = UINT64_C(0xffff7fff7fff0000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result.val[2]), 0);
         exp = UINT64_C(0x7fff80008000ffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result.val[2]), 1);
         exp = UINT64_C(0x000080008000ffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1358() {

{
   {
      float32_t arg1[12];
      float32x4x3_t result;
      char* str1 = "ReproInfo2 {semantics = \"load3\", fnname = \"vld3q_f32\", rettype = \"float32x4x3_t\", argtypes = \"[__transfersize(12) float32_t const *]\", vals = [PtrVal [FloatVal 0.618554413318634,FloatVal 0.1274247169494629,FloatVal 5.677223205566406e-2,FloatVal 0.4891127347946167,FloatVal 0.8659058213233948,FloatVal 0.43562960624694824,FloatVal 0.7439265251159668,FloatVal 0.879361093044281,FloatVal 0.661167323589325,FloatVal 0.9616469740867615,FloatVal 3.123188018798828e-2,FloatVal 0.20089846849441528]], start_saturated = False}";
      int reported = 0;
      arg1[0] = ((float32_t) 0.618554413318634);
      arg1[1] = ((float32_t) 0.1274247169494629);
      arg1[2] = ((float32_t) 5.677223205566406e-2);
      arg1[3] = ((float32_t) 0.4891127347946167);
      arg1[4] = ((float32_t) 0.8659058213233948);
      arg1[5] = ((float32_t) 0.43562960624694824);
      arg1[6] = ((float32_t) 0.7439265251159668);
      arg1[7] = ((float32_t) 0.879361093044281);
      arg1[8] = ((float32_t) 0.661167323589325);
      arg1[9] = ((float32_t) 0.9616469740867615);
      arg1[10] = ((float32_t) 3.123188018798828e-2);
      arg1[11] = ((float32_t) 0.20089846849441528);
      clear_neon_saturated();
      //  Expect: "result" = 3e4db8543f2942433edf0ad83d688a003cffda003f611dcf3f5dac013e027ba03f762e7f3f3e71f83efa6cfc3f1e5995
      result = vld3q_f32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result.val[0], 0);
         exp = ((float32_t) 0.618554413318634);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 0 ",
                      exp,
                      got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result.val[0], 1);
         exp = ((float32_t) 0.4891127347946167);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 1 ",
                      exp,
                      got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result.val[0], 2);
         exp = ((float32_t) 0.7439265251159668);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 2 ",
                      exp,
                      got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result.val[0], 3);
         exp = ((float32_t) 0.9616469740867615);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 3 ",
                      exp,
                      got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result.val[1], 0);
         exp = ((float32_t) 0.1274247169494629);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 0 ",
                      exp,
                      got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result.val[1], 1);
         exp = ((float32_t) 0.8659058213233948);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 1 ",
                      exp,
                      got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result.val[1], 2);
         exp = ((float32_t) 0.879361093044281);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 2 ",
                      exp,
                      got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result.val[1], 3);
         exp = ((float32_t) 3.123188018798828e-2);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 3 ",
                      exp,
                      got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result.val[2], 0);
         exp = ((float32_t) 5.677223205566406e-2);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 2 Lane 0 ",
                      exp,
                      got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result.val[2], 1);
         exp = ((float32_t) 0.43562960624694824);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 2 Lane 1 ",
                      exp,
                      got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result.val[2], 2);
         exp = ((float32_t) 0.661167323589325);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 2 Lane 2 ",
                      exp,
                      got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result.val[2], 3);
         exp = ((float32_t) 0.20089846849441528);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 2 Lane 3 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1359() {

{
   {
      float64_t arg1[6];
      float64x2x3_t result;
      char* str1 = "ReproInfo2 {semantics = \"load3\", fnname = \"vld3q_f64\", rettype = \"float64x2x3_t\", argtypes = \"[__transfersize(6) float64_t const *]\", vals = [PtrVal [FloatVal 0.9053105164252885,FloatVal 0.27180985789185075,FloatVal 0.19613590729602515,FloatVal 0.8793827492464601,FloatVal 9.762835536708292e-2,FloatVal 0.8424213271608535]], start_saturated = True}";
      int reported = 0;
      arg1[0] = 0.9053105164252885;
      arg1[1] = 0.27180985789185075;
      arg1[2] = 0.19613590729602515;
      arg1[3] = 0.8793827492464601;
      arg1[4] = 9.762835536708292e-2;
      arg1[5] = 0.8424213271608535;
      set_neon_saturated();
      //  Expect: "result" = 3feaf51d92337b253fc91afb3db430083fb8fe2c0176c1503fd165552c980eda3fec23e74a95c3803fecf84dc298b001
      result = vld3q_f64(arg1);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      {
         float64_t got;
         float64_t exp;
         got = vgetq_lane_f64(result.val[0], 0);
         exp = 0.9053105164252885;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 0 ",
                      exp,
                      got);
            }
      }
      {
         float64_t got;
         float64_t exp;
         got = vgetq_lane_f64(result.val[0], 1);
         exp = 0.8793827492464601;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 1 ",
                      exp,
                      got);
            }
      }
      {
         float64_t got;
         float64_t exp;
         got = vgetq_lane_f64(result.val[1], 0);
         exp = 0.27180985789185075;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 0 ",
                      exp,
                      got);
            }
      }
      {
         float64_t got;
         float64_t exp;
         got = vgetq_lane_f64(result.val[1], 1);
         exp = 9.762835536708292e-2;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 1 ",
                      exp,
                      got);
            }
      }
      {
         float64_t got;
         float64_t exp;
         got = vgetq_lane_f64(result.val[2], 0);
         exp = 0.19613590729602515;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 2 Lane 0 ",
                      exp,
                      got);
            }
      }
      {
         float64_t got;
         float64_t exp;
         got = vgetq_lane_f64(result.val[2], 1);
         exp = 0.8424213271608535;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 2 Lane 1 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1360() {

{
   {
      poly8_t arg1[48];
      poly8x16x3_t result;
      char* str1 = "ReproInfo2 {semantics = \"load3\", fnname = \"vld3q_p8\", rettype = \"poly8x16x3_t\", argtypes = \"[__transfersize(48) poly8_t const *]\", vals = [PtrVal [PolyVal [1,0,1,1,0,0,0,1],PolyVal [0,0,1,1,1,1,1,0],PolyVal [1,1,1,1,1,0,0,0],PolyVal [1,1,1,0,1,1,1,1],PolyVal [1,1,0,0,0,0,1,1],PolyVal [1,1,0,0,1,1,0,1],PolyVal [0,1,1,0,0,1,0,1],PolyVal [1,1,0,1,1,0,1,1],PolyVal [1,0,0,0,1,1,0,0],PolyVal [1,0,0,0,1,0,0,1],PolyVal [0,0,1,0,1,1,0,1],PolyVal [1,1,1,1,0,0,1,1],PolyVal [0,0,0,1,1,1,1,1],PolyVal [0,0,1,0,0,1,0,0],PolyVal [0,1,1,1,0,0,1,0],PolyVal [0,0,1,1,0,1,1,0],PolyVal [1,0,1,0,0,0,0,1],PolyVal [0,1,0,0,0,1,1,1],PolyVal [1,0,1,0,1,0,1,0],PolyVal [0,1,1,1,0,0,0,1],PolyVal [0,0,1,1,1,0,0,1],PolyVal [0,0,1,1,0,1,1,1],PolyVal [0,0,0,1,0,0,0,0],PolyVal [0,1,0,0,1,1,1,0],PolyVal [0,1,1,0,0,1,1,0],PolyVal [0,0,0,1,1,0,1,0],PolyVal [1,0,0,1,0,0,0,0],PolyVal [1,1,0,1,1,1,0,1],PolyVal [1,0,0,1,1,1,1,0],PolyVal [1,1,1,1,1,0,0,0],PolyVal [1,0,0,1,0,1,1,0],PolyVal [1,1,0,0,0,0,1,0],PolyVal [1,1,0,1,0,1,1,0],PolyVal [1,0,0,0,0,1,1,1],PolyVal [1,0,1,1,0,0,1,1],PolyVal [1,1,1,1,1,0,0,0],PolyVal [0,0,1,0,0,1,0,0],PolyVal [1,0,1,0,1,0,0,0],PolyVal [0,1,0,1,1,0,1,1],PolyVal [1,1,0,1,0,1,1,1],PolyVal [0,1,0,0,0,0,0,1],PolyVal [0,1,0,0,1,1,1,0],PolyVal [0,1,1,0,1,1,1,0],PolyVal [0,0,0,1,1,0,0,0],PolyVal [1,1,1,1,0,0,1,1],PolyVal [1,0,0,1,0,1,0,0],PolyVal [1,1,1,0,1,0,1,0],PolyVal [0,0,1,1,0,0,1,0]]], start_saturated = False}";
      int reported = 0;
      arg1[0] = 141;
      arg1[1] = 124;
      arg1[2] = 31;
      arg1[3] = 247;
      arg1[4] = 195;
      arg1[5] = 179;
      arg1[6] = 166;
      arg1[7] = 219;
      arg1[8] = 49;
      arg1[9] = 145;
      arg1[10] = 180;
      arg1[11] = 207;
      arg1[12] = 248;
      arg1[13] = 36;
      arg1[14] = 78;
      arg1[15] = 108;
      arg1[16] = 133;
      arg1[17] = 226;
      arg1[18] = 85;
      arg1[19] = 142;
      arg1[20] = 156;
      arg1[21] = 236;
      arg1[22] = 8;
      arg1[23] = 114;
      arg1[24] = 102;
      arg1[25] = 88;
      arg1[26] = 9;
      arg1[27] = 187;
      arg1[28] = 121;
      arg1[29] = 31;
      arg1[30] = 105;
      arg1[31] = 67;
      arg1[32] = 107;
      arg1[33] = 225;
      arg1[34] = 205;
      arg1[35] = 31;
      arg1[36] = 36;
      arg1[37] = 21;
      arg1[38] = 218;
      arg1[39] = 235;
      arg1[40] = 130;
      arg1[41] = 114;
      arg1[42] = 118;
      arg1[43] = 24;
      arg1[44] = 207;
      arg1[45] = 41;
      arg1[46] = 87;
      arg1[47] = 76;
      clear_neon_saturated();
      //  Expect: "result" = 4ccf72da1f6b1f09729ce24ecf31b31f57188215cd437958088e8524b4dbc37c2976eb24e169bb66ec556cf891a6f78d
      result = vld3q_p8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p8(result.val[0]), 0);
         exp = UINT64_C(0xec556cf891a6f78d);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p8(result.val[0]), 1);
         exp = UINT64_C(0x2976eb24e169bb66);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p8(result.val[1]), 0);
         exp = UINT64_C(0x088e8524b4dbc37c);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p8(result.val[1]), 1);
         exp = UINT64_C(0x57188215cd437958);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p8(result.val[2]), 0);
         exp = UINT64_C(0x729ce24ecf31b31f);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p8(result.val[2]), 1);
         exp = UINT64_C(0x4ccf72da1f6b1f09);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1361() {

{
   {
      poly16_t arg1[24];
      poly16x8x3_t result;
      char* str1 = "ReproInfo2 {semantics = \"load3\", fnname = \"vld3q_p16\", rettype = \"poly16x8x3_t\", argtypes = \"[__transfersize(24) poly16_t const *]\", vals = [PtrVal [PolyVal [0,1,1,0,0,0,1,1,0,0,0,0,0,0,1,0],PolyVal [1,0,1,0,1,0,0,1,1,1,0,1,0,0,1,1],PolyVal [1,1,0,0,1,0,0,0,0,1,0,1,1,0,0,1],PolyVal [0,0,0,1,1,0,1,1,0,1,0,1,0,1,1,0],PolyVal [1,1,0,0,1,1,1,0,1,0,0,0,1,1,1,1],PolyVal [1,1,1,1,0,0,0,0,1,1,0,1,1,0,1,0],PolyVal [1,1,1,1,0,1,0,1,1,0,1,0,0,0,0,0],PolyVal [0,0,1,0,1,0,1,0,0,0,0,0,0,0,1,0],PolyVal [1,0,1,1,0,1,1,1,1,1,1,0,1,0,0,0],PolyVal [0,0,0,0,0,0,1,1,0,1,1,0,0,1,0,0],PolyVal [0,1,0,1,0,0,1,0,1,1,1,1,1,0,0,0],PolyVal [1,0,0,0,1,1,1,1,1,1,0,0,1,1,1,0],PolyVal [0,0,1,0,1,0,0,1,1,1,1,0,0,0,1,1],PolyVal [1,1,1,0,1,0,0,1,0,0,1,1,1,1,0,0],PolyVal [1,0,0,0,0,1,1,1,1,0,0,1,0,1,0,1],PolyVal [1,0,0,0,1,0,1,0,1,1,1,0,1,1,0,0],PolyVal [0,0,0,0,0,0,1,1,0,1,1,0,1,1,0,1],PolyVal [1,1,1,1,1,1,0,0,0,1,1,1,0,0,0,0],PolyVal [1,0,0,1,1,0,0,0,1,1,0,0,0,1,1,1],PolyVal [1,1,0,0,0,1,0,0,1,0,0,1,1,1,0,0],PolyVal [0,1,0,0,1,0,1,1,0,0,0,1,1,0,1,1],PolyVal [0,1,0,1,0,0,1,1,0,0,1,1,1,0,0,1],PolyVal [0,0,1,1,0,1,1,0,0,0,1,1,1,1,1,1],PolyVal [0,1,0,1,0,0,0,0,1,0,1,0,1,0,0,1]]], start_saturated = False}";
      int reported = 0;
      arg1[0] = 16582;
      arg1[1] = 52117;
      arg1[2] = 39443;
      arg1[3] = 27352;
      arg1[4] = 61811;
      arg1[5] = 23311;
      arg1[6] = 1455;
      arg1[7] = 16468;
      arg1[8] = 6125;
      arg1[9] = 9920;
      arg1[10] = 8010;
      arg1[11] = 29681;
      arg1[12] = 51092;
      arg1[13] = 15511;
      arg1[14] = 43489;
      arg1[15] = 14161;
      arg1[16] = 46784;
      arg1[17] = 3647;
      arg1[18] = 58137;
      arg1[19] = 14627;
      arg1[20] = 55506;
      arg1[21] = 40138;
      arg1[22] = 64620;
      arg1[23] = 38154;
      clear_neon_saturated();
      //  Expect: "result" = 950ad8d20e3fa9e173f117ed5b0f9a13fc6c3923b6c03c971f4a4054f173cb959ccae3193751c79426c005af6ad840c6
      result = vld3q_p16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p16(result.val[0]), 0);
         exp = UINT64_C(0x26c005af6ad840c6);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p16(result.val[0]), 1);
         exp = UINT64_C(0x9ccae3193751c794);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p16(result.val[1]), 0);
         exp = UINT64_C(0x1f4a4054f173cb95);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p16(result.val[1]), 1);
         exp = UINT64_C(0xfc6c3923b6c03c97);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p16(result.val[2]), 0);
         exp = UINT64_C(0x73f117ed5b0f9a13);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p16(result.val[2]), 1);
         exp = UINT64_C(0x950ad8d20e3fa9e1);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1362() {
#if __ARM_NEON_FP16_INTRINSICS

{
   {
      __fp16 arg1[24];
      float16x8x3_t result;
      char* str1 = "ReproInfo2 {semantics = \"load3\", fnname = \"vld3q_f16\", rettype = \"float16x8x3_t\", argtypes = \"[__transfersize(24) __fp16 const *]\", vals = [PtrVal [FloatVal 7.572235311468123,FloatVal (-6.062337511518581),FloatVal (-3.984773067623742),FloatVal 1.7651604374663439,FloatVal 9.965639037440155,FloatVal 7.5790521553493235,FloatVal (-2.1270953930779584),FloatVal 5.780937219025725,FloatVal (-8.216922996223397),FloatVal 9.44573742731668,FloatVal (-0.24111184902714555),FloatVal 0.3812452806195381,FloatVal (-2.764520628489846),FloatVal (-5.090542889150161),FloatVal (-7.075703312022494),FloatVal 4.817224572763996,FloatVal 2.962081044114573,FloatVal 6.967484879073734,FloatVal (-6.332706229730789),FloatVal (-7.543718235805031),FloatVal 9.092056325948263,FloatVal 5.387030929604721,FloatVal (-0.21336380291661072),FloatVal 7.2450847086744545]], start_saturated = False}";
      int reported = 0;
      arg1[0] = 7.572235311468123;
      arg1[1] = -6.062337511518581;
      arg1[2] = -3.984773067623742;
      arg1[3] = 1.7651604374663439;
      arg1[4] = 9.965639037440155;
      arg1[5] = 7.5790521553493235;
      arg1[6] = -2.1270953930779584;
      arg1[7] = 5.780937219025725;
      arg1[8] = -8.216922996223397;
      arg1[9] = 9.44573742731668;
      arg1[10] = -0.24111184902714555;
      arg1[11] = 0.3812452806195381;
      arg1[12] = -2.764520628489846;
      arg1[13] = -5.090542889150161;
      arg1[14] = -7.075703312022494;
      arg1[15] = 4.817224572763996;
      arg1[16] = 2.962081044114573;
      arg1[17] = 6.967484879073734;
      arg1[18] = -6.332706229730789;
      arg1[19] = -7.543718235805031;
      arg1[20] = 9.092056325948263;
      arg1[21] = 5.387030929604721;
      arg1[22] = -0.21336380291661072;
      arg1[23] = 7.2450847086744545;
      clear_neon_saturated();
      //  Expect: "result" = 473e488b46f7c7133619c81b4794c3f8b2d3c78b41ecc517b3b745c748fbc60f4563c65544d1c18748b9c0413f0f4792
      result = vld3q_f16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[0], 0);
         exp = 7.572235311468123;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 0 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[0], 1);
         exp = 1.7651604374663439;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 1 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[0], 2);
         exp = -2.1270953930779584;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 2 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[0], 3);
         exp = 9.44573742731668;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 3 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[0], 4);
         exp = -2.764520628489846;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 4 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[0], 5);
         exp = 4.817224572763996;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 5 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[0], 6);
         exp = -6.332706229730789;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 6 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[0], 7);
         exp = 5.387030929604721;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 7 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[1], 0);
         exp = -6.062337511518581;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 0 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[1], 1);
         exp = 9.965639037440155;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 1 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[1], 2);
         exp = 5.780937219025725;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 2 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[1], 3);
         exp = -0.24111184902714555;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 3 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[1], 4);
         exp = -5.090542889150161;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 4 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[1], 5);
         exp = 2.962081044114573;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 5 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[1], 6);
         exp = -7.543718235805031;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 6 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[1], 7);
         exp = -0.21336380291661072;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 7 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[2], 0);
         exp = -3.984773067623742;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 2 Lane 0 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[2], 1);
         exp = 7.5790521553493235;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 2 Lane 1 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[2], 2);
         exp = -8.216922996223397;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 2 Lane 2 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[2], 3);
         exp = 0.3812452806195381;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 2 Lane 3 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[2], 4);
         exp = -7.075703312022494;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 2 Lane 4 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[2], 5);
         exp = 6.967484879073734;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 2 Lane 5 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[2], 6);
         exp = 9.092056325948263;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 2 Lane 6 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[2], 7);
         exp = 7.2450847086744545;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 2 Lane 7 ",
                      exp,
                      got);
            }
      }
   }
}
#endif
}
void dotests_1363() {

{
   {
      poly64_t arg1[6];
      poly64x2x3_t result;
      char* str1 = "ReproInfo2 {semantics = \"load3\", fnname = \"vld3q_p64\", rettype = \"poly64x2x3_t\", argtypes = \"[__transfersize(6) poly64_t const *]\", vals = [PtrVal [PolyVal [0,1,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,1,1,1,0,0,1,0,0,1,1,1,0,1,1,0,1,1,1,1,0,1,1,1,0,0,1,1,1,0,0,0,0,1,0,0,1,1,1,0,1,1,1,0,1,1,1],PolyVal [1,0,0,1,0,1,0,1,1,0,0,0,1,0,1,0,0,0,0,1,1,0,0,1,1,0,1,1,1,1,1,1,0,1,1,0,1,1,1,0,1,0,1,1,0,1,0,0,1,0,1,0,0,1,0,1,1,0,1,0,1,1,1,1],PolyVal [0,1,1,1,1,0,1,0,1,0,0,1,0,1,0,0,1,0,0,1,1,1,0,0,1,1,1,1,0,1,0,1,1,0,1,1,0,0,0,0,1,1,1,1,0,0,0,0,1,0,1,0,1,1,0,1,0,1,0,1,1,1,0,0],PolyVal [0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,1,1,0,1,1,1,0,0,1,1,0,0,0,0,0,0,1,0,1,0,1,1,1,1,1,0,1,0,0,1,0,0,1,1,1,0,1,1,0],PolyVal [0,1,0,0,1,1,0,1,1,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,1,0,0,0,1,1,0,0,1,0,0,1,1,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,1,1,1,1,0,1],PolyVal [1,0,1,1,1,1,1,1,0,0,0,0,0,1,1,0,1,0,1,0,1,0,1,1,1,1,1,0,0,1,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,1,0,1,0,0,1,1,1,1,1,0,1,0,0,1,1,0,1,0]]], start_saturated = False}";
      int reported = 0;
      arg1[0] = -1232796768645871478;
      arg1[1] = -746140174175940183;
      arg1[2] = 4230303976433199454;
      arg1[3] = 7947703280896475408;
      arg1[4] = -4827645729155545678;
      arg1[5] = 6448205514723909885;
      clear_neon_saturated();
      //  Expect: "result" = 597ca0c067d560fd3ab50f0daf39295ebd00c1c98c4085b2f5a52d76fd9851a96e4bea06760a8110eee439dedc9d088a
      result = vld3q_p64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p64(result.val[0]), 0);
         exp = UINT64_C(0xeee439dedc9d088a);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p64(result.val[0]), 1);
         exp = UINT64_C(0x6e4bea06760a8110);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p64(result.val[1]), 0);
         exp = UINT64_C(0xf5a52d76fd9851a9);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p64(result.val[1]), 1);
         exp = UINT64_C(0xbd00c1c98c4085b2);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p64(result.val[2]), 0);
         exp = UINT64_C(0x3ab50f0daf39295e);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p64(result.val[2]), 1);
         exp = UINT64_C(0x597ca0c067d560fd);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1364() {

{
   {
      uint8_t arg1[24];
      uint8x8x3_t result;
      char* str1 = "ReproInfo2 {semantics = \"load3\", fnname = \"vld3_u8\", rettype = \"uint8x8x3_t\", argtypes = \"[__transfersize(24) uint8_t const *]\", vals = [PtrVal [IntegerVal 0,IntegerVal 100,IntegerVal 61,IntegerVal 0,IntegerVal 127,IntegerVal 255,IntegerVal 170,IntegerVal 18,IntegerVal 128,IntegerVal 128,IntegerVal 231,IntegerVal 128,IntegerVal 33,IntegerVal 255,IntegerVal 128,IntegerVal 127,IntegerVal 128,IntegerVal 255,IntegerVal 99,IntegerVal 128,IntegerVal 255,IntegerVal 217,IntegerVal 0,IntegerVal 0]], start_saturated = False}";
      int reported = 0;
      arg1[0] = 0;
      arg1[1] = 100U;
      arg1[2] = 61U;
      arg1[3] = 0;
      arg1[4] = 127U;
      arg1[5] = 255U;
      arg1[6] = 170U;
      arg1[7] = 18U;
      arg1[8] = 128U;
      arg1[9] = 128U;
      arg1[10] = 231U;
      arg1[11] = 128U;
      arg1[12] = 33U;
      arg1[13] = 255U;
      arg1[14] = 128U;
      arg1[15] = 127U;
      arg1[16] = 128U;
      arg1[17] = 255U;
      arg1[18] = 99U;
      arg1[19] = 128U;
      arg1[20] = 255U;
      arg1[21] = 217U;
      arg1[22] = 0;
      arg1[23] = 0;
      clear_neon_saturated();
      //  Expect: "result" = 00ffff808080ff3d008080ffe7127f64d9637f2180aa0000
      result = vld3_u8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_u8(result.val[0]), 0);
         exp = UINT64_C(0xd9637f2180aa0000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_u8(result.val[1]), 0);
         exp = UINT64_C(0x008080ffe7127f64);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_u8(result.val[2]), 0);
         exp = UINT64_C(0x00ffff808080ff3d);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1365() {

{
   {
      uint16_t arg1[12];
      uint16x4x3_t result;
      char* str1 = "ReproInfo2 {semantics = \"load3\", fnname = \"vld3_u16\", rettype = \"uint16x4x3_t\", argtypes = \"[__transfersize(12) uint16_t const *]\", vals = [PtrVal [IntegerVal 32767,IntegerVal 32767,IntegerVal 40493,IntegerVal 32768,IntegerVal 65535,IntegerVal 32768,IntegerVal 32767,IntegerVal 32767,IntegerVal 32768,IntegerVal 26771,IntegerVal 32768,IntegerVal 32768]], start_saturated = False}";
      int reported = 0;
      arg1[0] = 32767U;
      arg1[1] = 32767U;
      arg1[2] = 40493U;
      arg1[3] = 32768U;
      arg1[4] = 65535U;
      arg1[5] = 32768U;
      arg1[6] = 32767U;
      arg1[7] = 32767U;
      arg1[8] = 32768U;
      arg1[9] = 26771U;
      arg1[10] = 32768U;
      arg1[11] = 32768U;
      clear_neon_saturated();
      //  Expect: "result" = 8000800080009e2d80007fffffff7fff68937fff80007fff
      result = vld3_u16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_u16(result.val[0]), 0);
         exp = UINT64_C(0x68937fff80007fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_u16(result.val[1]), 0);
         exp = UINT64_C(0x80007fffffff7fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_u16(result.val[2]), 0);
         exp = UINT64_C(0x8000800080009e2d);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1366() {

{
   {
      uint32_t arg1[6];
      uint32x2x3_t result;
      char* str1 = "ReproInfo2 {semantics = \"load3\", fnname = \"vld3_u32\", rettype = \"uint32x2x3_t\", argtypes = \"[__transfersize(6) uint32_t const *]\", vals = [PtrVal [IntegerVal 2147483648,IntegerVal 2147529386,IntegerVal 0,IntegerVal 42252,IntegerVal 2147498008,IntegerVal 3510435839]], start_saturated = False}";
      int reported = 0;
      arg1[0] = 2147483648U;
      arg1[1] = 2147529386U;
      arg1[2] = 0;
      arg1[3] = 42252U;
      arg1[4] = 2147498008U;
      arg1[5] = 3510435839U;
      clear_neon_saturated();
      //  Expect: "result" = d13cffff00000000800038188000b2aa0000a50c80000000
      result = vld3_u32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_u32(result.val[0]), 0);
         exp = UINT64_C(0x0000a50c80000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_u32(result.val[1]), 0);
         exp = UINT64_C(0x800038188000b2aa);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_u32(result.val[2]), 0);
         exp = UINT64_C(0xd13cffff00000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1367() {

{
   {
      uint64_t arg1[3];
      uint64x1x3_t result;
      char* str1 = "ReproInfo2 {semantics = \"load3\", fnname = \"vld3_u64\", rettype = \"uint64x1x3_t\", argtypes = \"[__transfersize(3) uint64_t const *]\", vals = [PtrVal [IntegerVal 18446744071562013023,IntegerVal 9223220010044915711,IntegerVal 18446603338368647168]], start_saturated = False}";
      int reported = 0;
      arg1[0] = UINT64_C(0xffffffff7fff295f);
      arg1[1] = UINT64_C(0x7fff75bb80007fff);
      arg1[2] = UINT64_C(0xffff80007fff8000);
      clear_neon_saturated();
      //  Expect: "result" = ffff80007fff80007fff75bb80007fffffffffff7fff295f
      result = vld3_u64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(result.val[0], 0);
         exp = UINT64_C(0xffffffff7fff295f);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(result.val[1], 0);
         exp = UINT64_C(0x7fff75bb80007fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(result.val[2], 0);
         exp = UINT64_C(0xffff80007fff8000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1368() {

{
   {
      int8_t arg1[24];
      int8x8x3_t result;
      char* str1 = "ReproInfo2 {semantics = \"load3\", fnname = \"vld3_s8\", rettype = \"int8x8x3_t\", argtypes = \"[__transfersize(24) int8_t const *]\", vals = [PtrVal [IntegerVal 0,IntegerVal (-53),IntegerVal 127,IntegerVal (-71),IntegerVal 127,IntegerVal 127,IntegerVal (-1),IntegerVal (-128),IntegerVal (-1),IntegerVal (-128),IntegerVal (-1),IntegerVal 60,IntegerVal (-1),IntegerVal 0,IntegerVal (-79),IntegerVal (-1),IntegerVal 0,IntegerVal (-128),IntegerVal (-1),IntegerVal (-128),IntegerVal (-1),IntegerVal (-1),IntegerVal (-128),IntegerVal (-128)]], start_saturated = False}";
      int reported = 0;
      arg1[0] = 0;
      arg1[1] = -53;
      arg1[2] = 127;
      arg1[3] = -71;
      arg1[4] = 127;
      arg1[5] = 127;
      arg1[6] = -1;
      arg1[7] = -128;
      arg1[8] = -1;
      arg1[9] = -128;
      arg1[10] = -1;
      arg1[11] = 60;
      arg1[12] = -1;
      arg1[13] = 0;
      arg1[14] = -79;
      arg1[15] = -1;
      arg1[16] = 0;
      arg1[17] = -128;
      arg1[18] = -1;
      arg1[19] = -128;
      arg1[20] = -1;
      arg1[21] = -1;
      arg1[22] = -128;
      arg1[23] = -128;
      clear_neon_saturated();
      //  Expect: "result" = 80ff80b13cff7f7f80800000ff807fcbffffffff80ffb900
      result = vld3_s8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_s8(result.val[0]), 0);
         exp = UINT64_C(0xffffffff80ffb900);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_s8(result.val[1]), 0);
         exp = UINT64_C(0x80800000ff807fcb);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_s8(result.val[2]), 0);
         exp = UINT64_C(0x80ff80b13cff7f7f);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1369() {

{
   {
      int16_t arg1[12];
      int16x4x3_t result;
      char* str1 = "ReproInfo2 {semantics = \"load3\", fnname = \"vld3_s16\", rettype = \"int16x4x3_t\", argtypes = \"[__transfersize(12) int16_t const *]\", vals = [PtrVal [IntegerVal 0,IntegerVal 0,IntegerVal 0,IntegerVal 0,IntegerVal (-1),IntegerVal (-32768),IntegerVal (-1),IntegerVal (-1),IntegerVal (-24063),IntegerVal 32767,IntegerVal (-32768),IntegerVal 10585]], start_saturated = True}";
      int reported = 0;
      arg1[0] = 0;
      arg1[1] = 0;
      arg1[2] = 0;
      arg1[3] = 0;
      arg1[4] = -1;
      arg1[5] = -32768;
      arg1[6] = -1;
      arg1[7] = -1;
      arg1[8] = -24063;
      arg1[9] = 32767;
      arg1[10] = -32768;
      arg1[11] = 10585;
      set_neon_saturated();
      //  Expect: "result" = 2959a201800000008000ffffffff00007fffffff00000000
      result = vld3_s16(arg1);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_s16(result.val[0]), 0);
         exp = UINT64_C(0x7fffffff00000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_s16(result.val[1]), 0);
         exp = UINT64_C(0x8000ffffffff0000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_s16(result.val[2]), 0);
         exp = UINT64_C(0x2959a20180000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1370() {

{
   {
      int32_t arg1[6];
      int32x2x3_t result;
      char* str1 = "ReproInfo2 {semantics = \"load3\", fnname = \"vld3_s32\", rettype = \"int32x2x3_t\", argtypes = \"[__transfersize(6) int32_t const *]\", vals = [PtrVal [IntegerVal 1735592541,IntegerVal (-32769),IntegerVal 2147450880,IntegerVal (-2147450880),IntegerVal 37098,IntegerVal (-2147483648)]], start_saturated = False}";
      int reported = 0;
      arg1[0] = 1735592541;
      arg1[1] = -32769;
      arg1[2] = 2147450880;
      arg1[3] = -2147450880;
      arg1[4] = 37098;
      arg1[5] = (int32_t) 0x80000000;
      clear_neon_saturated();
      //  Expect: "result" = 800000007fff8000000090eaffff7fff8000800067730a5d
      result = vld3_s32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_s32(result.val[0]), 0);
         exp = UINT64_C(0x8000800067730a5d);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_s32(result.val[1]), 0);
         exp = UINT64_C(0x000090eaffff7fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_s32(result.val[2]), 0);
         exp = UINT64_C(0x800000007fff8000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1371() {

{
   {
      int64_t arg1[3];
      int64x1x3_t result;
      char* str1 = "ReproInfo2 {semantics = \"load3\", fnname = \"vld3_s64\", rettype = \"int64x1x3_t\", argtypes = \"[__transfersize(3) int64_t const *]\", vals = [PtrVal [IntegerVal 99033355976703,IntegerVal (-4294967296),IntegerVal (-9223231303357464577)]], start_saturated = False}";
      int reported = 0;
      arg1[0] = INT64_C(99033355976703);
      arg1[1] = INT64_C(-4294967296);
      arg1[2] = INT64_C(-9223231303357464577);
      clear_neon_saturated();
      //  Expect: "result" = 80007fff121d7fffffffffff0000000000005a120000ffff
      result = vld3_s64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_s64(result.val[0]), 0);
         exp = UINT64_C(0x00005a120000ffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_s64(result.val[1]), 0);
         exp = UINT64_C(0xffffffff00000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_s64(result.val[2]), 0);
         exp = UINT64_C(0x80007fff121d7fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1372() {

{
   {
      float32_t arg1[6];
      float32x2x3_t result;
      char* str1 = "ReproInfo2 {semantics = \"load3\", fnname = \"vld3_f32\", rettype = \"float32x2x3_t\", argtypes = \"[__transfersize(6) float32_t const *]\", vals = [PtrVal [FloatVal 0.9505804777145386,FloatVal 0.7595636248588562,FloatVal 0.9522424936294556,FloatVal 0.7596518397331238,FloatVal 0.7664744853973389,FloatVal 0.36926496028900146]], start_saturated = False}";
      int reported = 0;
      arg1[0] = ((float32_t) 0.9505804777145386);
      arg1[1] = ((float32_t) 0.7595636248588562);
      arg1[2] = ((float32_t) 0.9522424936294556);
      arg1[3] = ((float32_t) 0.7596518397331238);
      arg1[4] = ((float32_t) 0.7664744853973389);
      arg1[5] = ((float32_t) 0.36926496028900146);
      clear_neon_saturated();
      //  Expect: "result" = 3ebd104c3f73c62a3f4437ac3f4272c33f42788b3f73593e
      result = vld3_f32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result.val[0], 0);
         exp = ((float32_t) 0.9505804777145386);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 0 ",
                      exp,
                      got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result.val[0], 1);
         exp = ((float32_t) 0.7596518397331238);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 1 ",
                      exp,
                      got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result.val[1], 0);
         exp = ((float32_t) 0.7595636248588562);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 0 ",
                      exp,
                      got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result.val[1], 1);
         exp = ((float32_t) 0.7664744853973389);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 1 ",
                      exp,
                      got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result.val[2], 0);
         exp = ((float32_t) 0.9522424936294556);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 2 Lane 0 ",
                      exp,
                      got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result.val[2], 1);
         exp = ((float32_t) 0.36926496028900146);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 2 Lane 1 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1373() {

{
   {
      float64_t arg1[3];
      float64x1x3_t result;
      char* str1 = "ReproInfo2 {semantics = \"load3\", fnname = \"vld3_f64\", rettype = \"float64x1x3_t\", argtypes = \"[__transfersize(3) float64_t const *]\", vals = [PtrVal [FloatVal 0.17617385113337325,FloatVal 0.21147216742850872,FloatVal 5.35878809915904e-2]], start_saturated = False}";
      int reported = 0;
      arg1[0] = 0.17617385113337325;
      arg1[1] = 0.21147216742850872;
      arg1[2] = 5.35878809915904e-2;
      clear_neon_saturated();
      //  Expect: "result" = 3fab6fdee8a442a03fcb11851d8f51b83fc68cdd60839c68
      result = vld3_f64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float64_t got;
         float64_t exp;
         got = vget_lane_f64(result.val[0], 0);
         exp = 0.17617385113337325;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 0 ",
                      exp,
                      got);
            }
      }
      {
         float64_t got;
         float64_t exp;
         got = vget_lane_f64(result.val[1], 0);
         exp = 0.21147216742850872;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 0 ",
                      exp,
                      got);
            }
      }
      {
         float64_t got;
         float64_t exp;
         got = vget_lane_f64(result.val[2], 0);
         exp = 5.35878809915904e-2;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 2 Lane 0 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1374() {

{
   {
      poly8_t arg1[24];
      poly8x8x3_t result;
      char* str1 = "ReproInfo2 {semantics = \"load3\", fnname = \"vld3_p8\", rettype = \"poly8x8x3_t\", argtypes = \"[__transfersize(24) poly8_t const *]\", vals = [PtrVal [PolyVal [0,1,1,1,1,0,1,1],PolyVal [1,1,1,0,0,0,1,1],PolyVal [0,0,1,1,0,1,1,0],PolyVal [1,0,0,0,1,0,0,0],PolyVal [1,1,1,0,0,1,1,1],PolyVal [1,0,1,0,1,0,1,1],PolyVal [1,0,1,1,1,0,1,0],PolyVal [0,1,0,0,1,1,1,1],PolyVal [0,0,1,1,0,0,0,0],PolyVal [1,1,0,1,0,1,1,1],PolyVal [0,1,1,0,0,1,1,1],PolyVal [1,1,0,1,0,0,1,0],PolyVal [1,0,1,1,0,1,1,0],PolyVal [0,1,1,1,0,1,0,0],PolyVal [1,1,1,1,0,0,1,1],PolyVal [1,0,1,0,0,0,0,1],PolyVal [0,1,1,1,1,0,1,0],PolyVal [0,1,1,1,1,1,1,1],PolyVal [1,0,1,1,1,1,0,0],PolyVal [0,1,0,1,1,1,1,0],PolyVal [0,1,0,0,1,1,0,1],PolyVal [1,1,1,1,0,1,0,1],PolyVal [0,1,0,1,1,0,1,0],PolyVal [0,0,1,0,0,1,0,1]]], start_saturated = False}";
      int reported = 0;
      arg1[0] = 222;
      arg1[1] = 199;
      arg1[2] = 108;
      arg1[3] = 17;
      arg1[4] = 231;
      arg1[5] = 213;
      arg1[6] = 93;
      arg1[7] = 242;
      arg1[8] = 12;
      arg1[9] = 235;
      arg1[10] = 230;
      arg1[11] = 75;
      arg1[12] = 109;
      arg1[13] = 46;
      arg1[14] = 207;
      arg1[15] = 133;
      arg1[16] = 94;
      arg1[17] = 254;
      arg1[18] = 61;
      arg1[19] = 122;
      arg1[20] = 178;
      arg1[21] = 175;
      arg1[22] = 90;
      arg1[23] = 164;
      clear_neon_saturated();
      //  Expect: "result" = a4b2fecf4b0cd56c5a7a5e2ee6f2e7c7af3d856deb5d11de
      result = vld3_p8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_p8(result.val[0]), 0);
         exp = UINT64_C(0xaf3d856deb5d11de);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_p8(result.val[1]), 0);
         exp = UINT64_C(0x5a7a5e2ee6f2e7c7);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_p8(result.val[2]), 0);
         exp = UINT64_C(0xa4b2fecf4b0cd56c);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1375() {

{
   {
      poly16_t arg1[12];
      poly16x4x3_t result;
      char* str1 = "ReproInfo2 {semantics = \"load3\", fnname = \"vld3_p16\", rettype = \"poly16x4x3_t\", argtypes = \"[__transfersize(12) poly16_t const *]\", vals = [PtrVal [PolyVal [1,0,0,1,1,1,0,0,0,0,0,1,1,0,0,1],PolyVal [0,0,0,0,0,1,1,1,0,1,0,1,0,0,0,0],PolyVal [1,0,0,0,1,0,1,1,1,1,1,0,0,1,1,0],PolyVal [1,1,1,0,1,1,0,0,1,1,0,0,1,1,1,0],PolyVal [1,0,1,1,0,0,0,1,1,1,1,0,0,0,0,1],PolyVal [0,0,0,0,1,0,1,0,1,0,0,1,1,0,0,0],PolyVal [1,0,1,1,0,1,0,0,0,0,1,0,1,0,0,1],PolyVal [1,1,0,0,0,1,0,0,0,0,0,1,0,0,1,1],PolyVal [0,0,0,1,0,0,1,0,0,1,0,1,1,1,0,1],PolyVal [1,0,0,1,1,0,0,1,1,0,0,0,0,1,0,1],PolyVal [1,0,0,1,1,0,1,0,0,0,1,1,1,0,1,1],PolyVal [1,1,1,0,0,1,1,1,1,1,1,1,1,1,0,1]]], start_saturated = False}";
      int reported = 0;
      arg1[0] = 38969;
      arg1[1] = 2784;
      arg1[2] = 26577;
      arg1[3] = 29495;
      arg1[4] = 34701;
      arg1[5] = 6480;
      arg1[6] = 37933;
      arg1[7] = 51235;
      arg1[8] = 47688;
      arg1[9] = 41369;
      arg1[10] = 56409;
      arg1[11] = 49127;
      clear_neon_saturated();
      //  Expect: "result" = bfe7ba48195067d1dc59c823878d0ae0a199942d73379839
      result = vld3_p16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_p16(result.val[0]), 0);
         exp = UINT64_C(0xa199942d73379839);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_p16(result.val[1]), 0);
         exp = UINT64_C(0xdc59c823878d0ae0);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_p16(result.val[2]), 0);
         exp = UINT64_C(0xbfe7ba48195067d1);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1376() {
#if __ARM_NEON_FP16_INTRINSICS

{
   {
      __fp16 arg1[12];
      float16x4x3_t result;
      char* str1 = "ReproInfo2 {semantics = \"load3\", fnname = \"vld3_f16\", rettype = \"float16x4x3_t\", argtypes = \"[__transfersize(12) __fp16 const *]\", vals = [PtrVal [FloatVal 9.389168196411152,FloatVal 2.785165713444762,FloatVal (-4.2821272791682645),FloatVal (-5.848523626619928),FloatVal (-8.37110441067221),FloatVal 0.26084004687355566,FloatVal (-4.127105979706373),FloatVal (-6.617230762320709),FloatVal 6.525627111012849,FloatVal (-3.796450787406041),FloatVal (-2.616593033219674),FloatVal 3.1602442825200256]], start_saturated = False}";
      int reported = 0;
      arg1[0] = 9.389168196411152;
      arg1[1] = 2.785165713444762;
      arg1[2] = -4.2821272791682645;
      arg1[3] = -5.848523626619928;
      arg1[4] = -8.37110441067221;
      arg1[5] = 0.26084004687355566;
      arg1[6] = -4.127105979706373;
      arg1[7] = -6.617230762320709;
      arg1[8] = 6.525627111012849;
      arg1[9] = -3.796450787406041;
      arg1[10] = -2.616593033219674;
      arg1[11] = 3.1602442825200256;
      clear_neon_saturated();
      //  Expect: "result" = 42524686342cc448c13bc69ec82f4192c397c420c5d948b1
      result = vld3_f16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         __fp16 got;
         __fp16 exp;
         got = vget_lane_f16(result.val[0], 0);
         exp = 9.389168196411152;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 0 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vget_lane_f16(result.val[0], 1);
         exp = -5.848523626619928;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 1 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vget_lane_f16(result.val[0], 2);
         exp = -4.127105979706373;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 2 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vget_lane_f16(result.val[0], 3);
         exp = -3.796450787406041;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 3 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vget_lane_f16(result.val[1], 0);
         exp = 2.785165713444762;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 0 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vget_lane_f16(result.val[1], 1);
         exp = -8.37110441067221;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 1 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vget_lane_f16(result.val[1], 2);
         exp = -6.617230762320709;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 2 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vget_lane_f16(result.val[1], 3);
         exp = -2.616593033219674;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 3 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vget_lane_f16(result.val[2], 0);
         exp = -4.2821272791682645;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 2 Lane 0 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vget_lane_f16(result.val[2], 1);
         exp = 0.26084004687355566;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 2 Lane 1 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vget_lane_f16(result.val[2], 2);
         exp = 6.525627111012849;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 2 Lane 2 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vget_lane_f16(result.val[2], 3);
         exp = 3.1602442825200256;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 2 Lane 3 ",
                      exp,
                      got);
            }
      }
   }
}
#endif
}
void dotests_1377() {

{
   {
      poly64_t arg1[3];
      poly64x1x3_t result;
      char* str1 = "ReproInfo2 {semantics = \"load3\", fnname = \"vld3_p64\", rettype = \"poly64x1x3_t\", argtypes = \"[__transfersize(3) poly64_t const *]\", vals = [PtrVal [PolyVal [1,0,1,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,1,1,0,1,0,1,0,1,0,0,1,1,0,0,0,1,1,1,1,1,1,1,1,1,0,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1],PolyVal [1,0,0,0,0,1,0,0,1,0,1,1,0,0,0,1,1,0,1,0,0,1,0,1,0,1,0,0,1,0,1,1,0,1,0,0,0,1,0,0,1,1,0,1,0,1,1,1,0,1,1,0,1,0,1,0,1,0,1,0,1,1,1,0],PolyVal [0,1,0,1,1,1,0,0,1,0,1,0,0,1,1,1,0,0,1,0,0,1,1,0,1,1,0,0,1,1,1,0,1,0,1,1,1,1,0,1,1,0,1,0,1,1,1,1,0,0,0,1,0,1,1,0,0,0,0,0,0,1,1,0]]], start_saturated = False}";
      int reported = 0;
      arg1[0] = -8898761143797413875;
      arg1[1] = 8455203885230165281;
      arg1[2] = 6947072619252606266;
      clear_neon_saturated();
      //  Expect: "result" = 6068f5bd7364e53a7556eb22d2a58d2184813fe32ae8080d
      result = vld3_p64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_p64(result.val[0]), 0);
         exp = UINT64_C(0x84813fe32ae8080d);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_p64(result.val[1]), 0);
         exp = UINT64_C(0x7556eb22d2a58d21);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_p64(result.val[2]), 0);
         exp = UINT64_C(0x6068f5bd7364e53a);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1378() {

{
   {
      uint8_t arg1[64];
      uint8x16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"load4\", fnname = \"vld4q_u8\", rettype = \"uint8x16x4_t\", argtypes = \"[__transfersize(64) uint8_t const *]\", vals = [PtrVal [IntegerVal 128,IntegerVal 0,IntegerVal 128,IntegerVal 128,IntegerVal 255,IntegerVal 127,IntegerVal 0,IntegerVal 255,IntegerVal 128,IntegerVal 127,IntegerVal 128,IntegerVal 127,IntegerVal 128,IntegerVal 12,IntegerVal 187,IntegerVal 255,IntegerVal 111,IntegerVal 255,IntegerVal 43,IntegerVal 0,IntegerVal 239,IntegerVal 38,IntegerVal 255,IntegerVal 0,IntegerVal 0,IntegerVal 0,IntegerVal 128,IntegerVal 255,IntegerVal 128,IntegerVal 127,IntegerVal 0,IntegerVal 128,IntegerVal 108,IntegerVal 255,IntegerVal 127,IntegerVal 127,IntegerVal 242,IntegerVal 255,IntegerVal 0,IntegerVal 196,IntegerVal 255,IntegerVal 127,IntegerVal 127,IntegerVal 79,IntegerVal 44,IntegerVal 0,IntegerVal 255,IntegerVal 164,IntegerVal 0,IntegerVal 0,IntegerVal 127,IntegerVal 0,IntegerVal 255,IntegerVal 49,IntegerVal 255,IntegerVal 0,IntegerVal 255,IntegerVal 0,IntegerVal 214,IntegerVal 128,IntegerVal 0,IntegerVal 127,IntegerVal 162,IntegerVal 127]], start_saturated = False}";
      int reported = 0;
      arg1[0] = 128U;
      arg1[1] = 0;
      arg1[2] = 128U;
      arg1[3] = 128U;
      arg1[4] = 255U;
      arg1[5] = 127U;
      arg1[6] = 0;
      arg1[7] = 255U;
      arg1[8] = 128U;
      arg1[9] = 127U;
      arg1[10] = 128U;
      arg1[11] = 127U;
      arg1[12] = 128U;
      arg1[13] = 12U;
      arg1[14] = 187U;
      arg1[15] = 255U;
      arg1[16] = 111U;
      arg1[17] = 255U;
      arg1[18] = 43U;
      arg1[19] = 0;
      arg1[20] = 239U;
      arg1[21] = 38U;
      arg1[22] = 255U;
      arg1[23] = 0;
      arg1[24] = 0;
      arg1[25] = 0;
      arg1[26] = 128U;
      arg1[27] = 255U;
      arg1[28] = 128U;
      arg1[29] = 127U;
      arg1[30] = 0;
      arg1[31] = 128U;
      arg1[32] = 108U;
      arg1[33] = 255U;
      arg1[34] = 127U;
      arg1[35] = 127U;
      arg1[36] = 242U;
      arg1[37] = 255U;
      arg1[38] = 0;
      arg1[39] = 196U;
      arg1[40] = 255U;
      arg1[41] = 127U;
      arg1[42] = 127U;
      arg1[43] = 79U;
      arg1[44] = 44U;
      arg1[45] = 0;
      arg1[46] = 255U;
      arg1[47] = 164U;
      arg1[48] = 0;
      arg1[49] = 0;
      arg1[50] = 127U;
      arg1[51] = 0;
      arg1[52] = 255U;
      arg1[53] = 49U;
      arg1[54] = 255U;
      arg1[55] = 0;
      arg1[56] = 255U;
      arg1[57] = 0;
      arg1[58] = 214U;
      arg1[59] = 128U;
      arg1[60] = 0;
      arg1[61] = 127U;
      arg1[62] = 162U;
      arg1[63] = 127U;
      clear_neon_saturated();
      //  Expect: "result" = 7f800000a44fc47f80ff0000ff7fff80a2d6ff7fff7f007f0080ff2bbb8000807f003100007fffff7f0026ff0c7f7f0000ffff002cfff26c8000ef6f8080ff80
      result = vld4q_u8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result.val[0]), 0);
         exp = UINT64_C(0x8000ef6f8080ff80);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result.val[0]), 1);
         exp = UINT64_C(0x00ffff002cfff26c);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result.val[1]), 0);
         exp = UINT64_C(0x7f0026ff0c7f7f00);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result.val[1]), 1);
         exp = UINT64_C(0x7f003100007fffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result.val[2]), 0);
         exp = UINT64_C(0x0080ff2bbb800080);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result.val[2]), 1);
         exp = UINT64_C(0xa2d6ff7fff7f007f);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result.val[3]), 0);
         exp = UINT64_C(0x80ff0000ff7fff80);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 3 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result.val[3]), 1);
         exp = UINT64_C(0x7f800000a44fc47f);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 3 High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1379() {

{
   {
      uint16_t arg1[32];
      uint16x8x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"load4\", fnname = \"vld4q_u16\", rettype = \"uint16x8x4_t\", argtypes = \"[__transfersize(32) uint16_t const *]\", vals = [PtrVal [IntegerVal 65535,IntegerVal 32767,IntegerVal 65535,IntegerVal 32767,IntegerVal 0,IntegerVal 0,IntegerVal 32767,IntegerVal 32768,IntegerVal 13915,IntegerVal 40690,IntegerVal 32768,IntegerVal 65535,IntegerVal 23486,IntegerVal 32768,IntegerVal 32768,IntegerVal 35405,IntegerVal 32767,IntegerVal 0,IntegerVal 65535,IntegerVal 0,IntegerVal 32768,IntegerVal 0,IntegerVal 32767,IntegerVal 32767,IntegerVal 65535,IntegerVal 32767,IntegerVal 65535,IntegerVal 65535,IntegerVal 0,IntegerVal 0,IntegerVal 47416,IntegerVal 32768]], start_saturated = False}";
      int reported = 0;
      arg1[0] = 65535U;
      arg1[1] = 32767U;
      arg1[2] = 65535U;
      arg1[3] = 32767U;
      arg1[4] = 0;
      arg1[5] = 0;
      arg1[6] = 32767U;
      arg1[7] = 32768U;
      arg1[8] = 13915U;
      arg1[9] = 40690U;
      arg1[10] = 32768U;
      arg1[11] = 65535U;
      arg1[12] = 23486U;
      arg1[13] = 32768U;
      arg1[14] = 32768U;
      arg1[15] = 35405U;
      arg1[16] = 32767U;
      arg1[17] = 0;
      arg1[18] = 65535U;
      arg1[19] = 0;
      arg1[20] = 32768U;
      arg1[21] = 0;
      arg1[22] = 32767U;
      arg1[23] = 32767U;
      arg1[24] = 65535U;
      arg1[25] = 32767U;
      arg1[26] = 65535U;
      arg1[27] = 65535U;
      arg1[28] = 0;
      arg1[29] = 0;
      arg1[30] = 47416U;
      arg1[31] = 32768U;
      clear_neon_saturated();
      //  Expect: "result" = 8000ffff7fff00008a4dffff80007fffb938ffff7fffffff800080007fffffff00007fff0000000080009ef200007fff0000ffff80007fff5bbe365b0000ffff
      result = vld4q_u16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result.val[0]), 0);
         exp = UINT64_C(0x5bbe365b0000ffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result.val[0]), 1);
         exp = UINT64_C(0x0000ffff80007fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result.val[1]), 0);
         exp = UINT64_C(0x80009ef200007fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result.val[1]), 1);
         exp = UINT64_C(0x00007fff00000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result.val[2]), 0);
         exp = UINT64_C(0x800080007fffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result.val[2]), 1);
         exp = UINT64_C(0xb938ffff7fffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result.val[3]), 0);
         exp = UINT64_C(0x8a4dffff80007fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 3 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result.val[3]), 1);
         exp = UINT64_C(0x8000ffff7fff0000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 3 High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1380() {

{
   {
      uint32_t arg1[16];
      uint32x4x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"load4\", fnname = \"vld4q_u32\", rettype = \"uint32x4x4_t\", argtypes = \"[__transfersize(16) uint32_t const *]\", vals = [PtrVal [IntegerVal 2147516415,IntegerVal 65535,IntegerVal 2147483648,IntegerVal 2147516416,IntegerVal 1267499007,IntegerVal 4098162688,IntegerVal 1337327615,IntegerVal 4294936272,IntegerVal 2147483648,IntegerVal 505872384,IntegerVal 2147503962,IntegerVal 4294901760,IntegerVal 3029794816,IntegerVal 1674674175,IntegerVal 2147483648,IntegerVal 2128838655]], start_saturated = False}";
      int reported = 0;
      arg1[0] = 2147516415U;
      arg1[1] = 65535U;
      arg1[2] = 2147483648U;
      arg1[3] = 2147516416U;
      arg1[4] = 1267499007U;
      arg1[5] = 4098162688U;
      arg1[6] = 1337327615U;
      arg1[7] = 4294936272U;
      arg1[8] = 2147483648U;
      arg1[9] = 505872384U;
      arg1[10] = 2147503962U;
      arg1[11] = 4294901760U;
      arg1[12] = 3029794816U;
      arg1[13] = 1674674175U;
      arg1[14] = 2147483648U;
      arg1[15] = 2128838655U;
      clear_neon_saturated();
      //  Expect: "result" = 7ee37fffffff0000ffff86d0800080008000000080004f5a4fb5ffff8000000063d17fff1e270000f44500000000ffffb4970000800000004b8c7fff80007fff
      result = vld4q_u32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result.val[0]), 0);
         exp = UINT64_C(0x4b8c7fff80007fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result.val[0]), 1);
         exp = UINT64_C(0xb497000080000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result.val[1]), 0);
         exp = UINT64_C(0xf44500000000ffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result.val[1]), 1);
         exp = UINT64_C(0x63d17fff1e270000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result.val[2]), 0);
         exp = UINT64_C(0x4fb5ffff80000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result.val[2]), 1);
         exp = UINT64_C(0x8000000080004f5a);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result.val[3]), 0);
         exp = UINT64_C(0xffff86d080008000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 3 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result.val[3]), 1);
         exp = UINT64_C(0x7ee37fffffff0000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 3 High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1381() {

{
   {
      uint64_t arg1[8];
      uint64x2x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"load4\", fnname = \"vld4q_u64\", rettype = \"uint64x2x4_t\", argtypes = \"[__transfersize(8) uint64_t const *]\", vals = [PtrVal [IntegerVal 18446603334073745407,IntegerVal 140739635806208,IntegerVal 9223090566172966912,IntegerVal 18446603336221196287,IntegerVal 9223231303661355007,IntegerVal 9223090562325217279,IntegerVal 4175461841033428992,IntegerVal 2694137737438625791]], start_saturated = False}";
      int reported = 0;
      arg1[0] = UINT64_C(0xffff7fff80007fff);
      arg1[1] = UINT64_C(0x000080007fff8000);
      arg1[2] = UINT64_C(0x7fff0000ffff0000);
      arg1[3] = UINT64_C(0xffff7fffffffffff);
      arg1[4] = UINT64_C(0x7fff8000ffff7fff);
      arg1[5] = UINT64_C(0x7fff00001aa6ffff);
      arg1[6] = UINT64_C(0x39f2386bffff0000);
      arg1[7] = UINT64_C(0x25637fff8000ffff);
      clear_neon_saturated();
      //  Expect: "result" = 25637fff8000ffffffff7fffffffffff39f2386bffff00007fff0000ffff00007fff00001aa6ffff000080007fff80007fff8000ffff7fffffff7fff80007fff
      result = vld4q_u64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result.val[0], 0);
         exp = UINT64_C(0xffff7fff80007fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result.val[0], 1);
         exp = UINT64_C(0x7fff8000ffff7fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result.val[1], 0);
         exp = UINT64_C(0x000080007fff8000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result.val[1], 1);
         exp = UINT64_C(0x7fff00001aa6ffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result.val[2], 0);
         exp = UINT64_C(0x7fff0000ffff0000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result.val[2], 1);
         exp = UINT64_C(0x39f2386bffff0000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result.val[3], 0);
         exp = UINT64_C(0xffff7fffffffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 3 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result.val[3], 1);
         exp = UINT64_C(0x25637fff8000ffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 3 High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1382() {

{
   {
      int8_t arg1[64];
      int8x16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"load4\", fnname = \"vld4q_s8\", rettype = \"int8x16x4_t\", argtypes = \"[__transfersize(64) int8_t const *]\", vals = [PtrVal [IntegerVal 127,IntegerVal 0,IntegerVal (-100),IntegerVal 127,IntegerVal 127,IntegerVal 95,IntegerVal 0,IntegerVal (-1),IntegerVal (-128),IntegerVal (-128),IntegerVal (-1),IntegerVal 0,IntegerVal (-1),IntegerVal 0,IntegerVal (-99),IntegerVal (-1),IntegerVal (-1),IntegerVal 0,IntegerVal (-128),IntegerVal 14,IntegerVal (-128),IntegerVal (-128),IntegerVal (-128),IntegerVal (-128),IntegerVal (-1),IntegerVal (-1),IntegerVal 0,IntegerVal (-49),IntegerVal (-128),IntegerVal 28,IntegerVal (-128),IntegerVal (-1),IntegerVal 0,IntegerVal (-1),IntegerVal (-1),IntegerVal 64,IntegerVal (-1),IntegerVal 0,IntegerVal 0,IntegerVal 0,IntegerVal (-128),IntegerVal 0,IntegerVal 127,IntegerVal 127,IntegerVal (-128),IntegerVal 0,IntegerVal 127,IntegerVal 0,IntegerVal (-1),IntegerVal (-128),IntegerVal 127,IntegerVal 127,IntegerVal (-40),IntegerVal 0,IntegerVal (-128),IntegerVal 127,IntegerVal (-1),IntegerVal (-128),IntegerVal (-1),IntegerVal 127,IntegerVal 127,IntegerVal 127,IntegerVal (-1),IntegerVal 118]], start_saturated = False}";
      int reported = 0;
      arg1[0] = 127;
      arg1[1] = 0;
      arg1[2] = -100;
      arg1[3] = 127;
      arg1[4] = 127;
      arg1[5] = 95;
      arg1[6] = 0;
      arg1[7] = -1;
      arg1[8] = -128;
      arg1[9] = -128;
      arg1[10] = -1;
      arg1[11] = 0;
      arg1[12] = -1;
      arg1[13] = 0;
      arg1[14] = -99;
      arg1[15] = -1;
      arg1[16] = -1;
      arg1[17] = 0;
      arg1[18] = -128;
      arg1[19] = 14;
      arg1[20] = -128;
      arg1[21] = -128;
      arg1[22] = -128;
      arg1[23] = -128;
      arg1[24] = -1;
      arg1[25] = -1;
      arg1[26] = 0;
      arg1[27] = -49;
      arg1[28] = -128;
      arg1[29] = 28;
      arg1[30] = -128;
      arg1[31] = -1;
      arg1[32] = 0;
      arg1[33] = -1;
      arg1[34] = -1;
      arg1[35] = 64;
      arg1[36] = -1;
      arg1[37] = 0;
      arg1[38] = 0;
      arg1[39] = 0;
      arg1[40] = -128;
      arg1[41] = 0;
      arg1[42] = 127;
      arg1[43] = 127;
      arg1[44] = -128;
      arg1[45] = 0;
      arg1[46] = 127;
      arg1[47] = 0;
      arg1[48] = -1;
      arg1[49] = -128;
      arg1[50] = 127;
      arg1[51] = 127;
      arg1[52] = -40;
      arg1[53] = 0;
      arg1[54] = -128;
      arg1[55] = 127;
      arg1[56] = -1;
      arg1[57] = -128;
      arg1[58] = -1;
      arg1[59] = 127;
      arg1[60] = 127;
      arg1[61] = 127;
      arg1[62] = -1;
      arg1[63] = 118;
      clear_neon_saturated();
      //  Expect: "result" = 767f7f7f007f0040ffcf800eff00ff7fffff807f7f7f00ff800080809dff009c7f800080000000ff1cff800000805f007fffd8ff8080ff0080ff80ffff807f7f
      result = vld4q_s8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result.val[0]), 0);
         exp = UINT64_C(0x80ff80ffff807f7f);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result.val[0]), 1);
         exp = UINT64_C(0x7fffd8ff8080ff00);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result.val[1]), 0);
         exp = UINT64_C(0x1cff800000805f00);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result.val[1]), 1);
         exp = UINT64_C(0x7f800080000000ff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result.val[2]), 0);
         exp = UINT64_C(0x800080809dff009c);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result.val[2]), 1);
         exp = UINT64_C(0xffff807f7f7f00ff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result.val[3]), 0);
         exp = UINT64_C(0xffcf800eff00ff7f);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 3 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result.val[3]), 1);
         exp = UINT64_C(0x767f7f7f007f0040);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 3 High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1383() {

{
   {
      int16_t arg1[32];
      int16x8x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"load4\", fnname = \"vld4q_s16\", rettype = \"int16x8x4_t\", argtypes = \"[__transfersize(32) int16_t const *]\", vals = [PtrVal [IntegerVal (-32768),IntegerVal (-1),IntegerVal 0,IntegerVal (-32768),IntegerVal 32767,IntegerVal (-1),IntegerVal 32767,IntegerVal 0,IntegerVal (-1),IntegerVal 32767,IntegerVal (-32768),IntegerVal (-32768),IntegerVal 0,IntegerVal 0,IntegerVal (-1),IntegerVal 32767,IntegerVal 32767,IntegerVal 32767,IntegerVal 32767,IntegerVal 17026,IntegerVal (-1286),IntegerVal 0,IntegerVal (-32768),IntegerVal (-1),IntegerVal (-32768),IntegerVal 0,IntegerVal 32767,IntegerVal (-32768),IntegerVal (-1),IntegerVal 0,IntegerVal (-32768),IntegerVal 32767]], start_saturated = False}";
      int reported = 0;
      arg1[0] = -32768;
      arg1[1] = -1;
      arg1[2] = 0;
      arg1[3] = -32768;
      arg1[4] = 32767;
      arg1[5] = -1;
      arg1[6] = 32767;
      arg1[7] = 0;
      arg1[8] = -1;
      arg1[9] = 32767;
      arg1[10] = -32768;
      arg1[11] = -32768;
      arg1[12] = 0;
      arg1[13] = 0;
      arg1[14] = -1;
      arg1[15] = 32767;
      arg1[16] = 32767;
      arg1[17] = 32767;
      arg1[18] = 32767;
      arg1[19] = 17026;
      arg1[20] = -1286;
      arg1[21] = 0;
      arg1[22] = -32768;
      arg1[23] = -1;
      arg1[24] = -32768;
      arg1[25] = 0;
      arg1[26] = 32767;
      arg1[27] = -32768;
      arg1[28] = -1;
      arg1[29] = 0;
      arg1[30] = -32768;
      arg1[31] = 32767;
      clear_neon_saturated();
      //  Expect: "result" = 7fff8000ffff42827fff80000000800080007fff80007fffffff80007fff00000000000000007fff00007fffffffffffffff8000fafa7fff0000ffff7fff8000
      result = vld4q_s16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result.val[0]), 0);
         exp = UINT64_C(0x0000ffff7fff8000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result.val[0]), 1);
         exp = UINT64_C(0xffff8000fafa7fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result.val[1]), 0);
         exp = UINT64_C(0x00007fffffffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result.val[1]), 1);
         exp = UINT64_C(0x0000000000007fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result.val[2]), 0);
         exp = UINT64_C(0xffff80007fff0000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result.val[2]), 1);
         exp = UINT64_C(0x80007fff80007fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result.val[3]), 0);
         exp = UINT64_C(0x7fff800000008000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 3 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result.val[3]), 1);
         exp = UINT64_C(0x7fff8000ffff4282);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 3 High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1384() {

{
   {
      int32_t arg1[16];
      int32x4x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"load4\", fnname = \"vld4q_s32\", rettype = \"int32x4x4_t\", argtypes = \"[__transfersize(16) int32_t const *]\", vals = [PtrVal [IntegerVal 0,IntegerVal 2147450879,IntegerVal 2147450879,IntegerVal 65535,IntegerVal (-1335516093),IntegerVal (-2147450881),IntegerVal (-32768),IntegerVal (-2147483648),IntegerVal 2147432853,IntegerVal (-2147483648),IntegerVal (-2147450880),IntegerVal (-551124992),IntegerVal 431554559,IntegerVal 2147450880,IntegerVal 2147450880,IntegerVal (-65536)]], start_saturated = False}";
      int reported = 0;
      arg1[0] = 0;
      arg1[1] = 2147450879;
      arg1[2] = 2147450879;
      arg1[3] = 65535;
      arg1[4] = -1335516093;
      arg1[5] = -2147450881;
      arg1[6] = -32768;
      arg1[7] = (int32_t) 0x80000000;
      arg1[8] = 2147432853;
      arg1[9] = (int32_t) 0x80000000;
      arg1[10] = -2147450880;
      arg1[11] = -551124992;
      arg1[12] = 431554559;
      arg1[13] = 2147450880;
      arg1[14] = 2147450880;
      arg1[15] = -65536;
      clear_neon_saturated();
      //  Expect: "result" = ffff0000df268000800000000000ffff7fff800080008000ffff80007fff7fff7fff80008000000080007fff7fff7fff19b8ffff7fff3995b065a44300000000
      result = vld4q_s32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result.val[0]), 0);
         exp = UINT64_C(0xb065a44300000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result.val[0]), 1);
         exp = UINT64_C(0x19b8ffff7fff3995);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result.val[1]), 0);
         exp = UINT64_C(0x80007fff7fff7fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result.val[1]), 1);
         exp = UINT64_C(0x7fff800080000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result.val[2]), 0);
         exp = UINT64_C(0xffff80007fff7fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result.val[2]), 1);
         exp = UINT64_C(0x7fff800080008000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result.val[3]), 0);
         exp = UINT64_C(0x800000000000ffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 3 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result.val[3]), 1);
         exp = UINT64_C(0xffff0000df268000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 3 High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1385() {

{
   {
      int64_t arg1[8];
      int64x2x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"load4\", fnname = \"vld4q_s64\", rettype = \"int64x2x4_t\", argtypes = \"[__transfersize(8) int64_t const *]\", vals = [PtrVal [IntegerVal (-9223253199404662784),IntegerVal (-578149606458621952),IntegerVal 140739635863150,IntegerVal (-8394273830662602752),IntegerVal 281472829161472,IntegerVal (-112589994979196929),IntegerVal 281474717777920,IntegerVal (-140733721673729)]], start_saturated = False}";
      int reported = 0;
      arg1[0] = INT64_C(-9223253199404662784);
      arg1[1] = INT64_C(-578149606458621952);
      arg1[2] = INT64_C(140739635863150);
      arg1[3] = INT64_C(-8394273830662602752);
      arg1[4] = INT64_C(281472829161472);
      arg1[5] = INT64_C(-112589994979196929);
      arg1[6] = INT64_C(281474717777920);
      arg1[7] = INT64_C(-140733721673729);
      clear_neon_saturated();
      //  Expect: "result" = ffff8000e082ffff8b818c6cffff80000000fffff09100000000800080005e6efe6fffff00007ffff7f9ffff000080000000ffff7fff000080006c1500000000
      result = vld4q_s64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result.val[0]), 0);
         exp = UINT64_C(0x80006c1500000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result.val[0]), 1);
         exp = UINT64_C(0x0000ffff7fff0000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result.val[1]), 0);
         exp = UINT64_C(0xf7f9ffff00008000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result.val[1]), 1);
         exp = UINT64_C(0xfe6fffff00007fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result.val[2]), 0);
         exp = UINT64_C(0x0000800080005e6e);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result.val[2]), 1);
         exp = UINT64_C(0x0000fffff0910000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result.val[3]), 0);
         exp = UINT64_C(0x8b818c6cffff8000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 3 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result.val[3]), 1);
         exp = UINT64_C(0xffff8000e082ffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 3 High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1386() {

{
   {
      float32_t arg1[16];
      float32x4x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"load4\", fnname = \"vld4q_f32\", rettype = \"float32x4x4_t\", argtypes = \"[__transfersize(16) float32_t const *]\", vals = [PtrVal [FloatVal 0.5655475854873657,FloatVal 0.6740353107452393,FloatVal 0.5906755924224854,FloatVal 0.8822932243347168,FloatVal 0.3009994626045227,FloatVal 0.8414262533187866,FloatVal 0.46078211069107056,FloatVal 0.4035298824310303,FloatVal 0.7073160409927368,FloatVal 0.554280161857605,FloatVal 0.7118404507637024,FloatVal 0.9445391893386841,FloatVal 0.4864059090614319,FloatVal 0.4461796283721924,FloatVal 0.16086608171463013,FloatVal 0.46389079093933105]], start_saturated = False}";
      int reported = 0;
      arg1[0] = ((float32_t) 0.5655475854873657);
      arg1[1] = ((float32_t) 0.6740353107452393);
      arg1[2] = ((float32_t) 0.5906755924224854);
      arg1[3] = ((float32_t) 0.8822932243347168);
      arg1[4] = ((float32_t) 0.3009994626045227);
      arg1[5] = ((float32_t) 0.8414262533187866);
      arg1[6] = ((float32_t) 0.46078211069107056);
      arg1[7] = ((float32_t) 0.4035298824310303);
      arg1[8] = ((float32_t) 0.7073160409927368);
      arg1[9] = ((float32_t) 0.554280161857605);
      arg1[10] = ((float32_t) 0.7118404507637024);
      arg1[11] = ((float32_t) 0.9445391893386841);
      arg1[12] = ((float32_t) 0.4864059090614319);
      arg1[13] = ((float32_t) 0.4461796283721924);
      arg1[14] = ((float32_t) 0.16086608171463013);
      arg1[15] = ((float32_t) 0.46389079093933105);
      clear_neon_saturated();
      //  Expect: "result" = 3eed83183f71cd523ece9b783f61ddf83e24ba143f363b2d3eebeba23f1736843ee471a83f0de54e3f5767b63f2c8d943ef90a323f3512aa3e9a1c9a3f10c7ba
      result = vld4q_f32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result.val[0], 0);
         exp = ((float32_t) 0.5655475854873657);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 0 ",
                      exp,
                      got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result.val[0], 1);
         exp = ((float32_t) 0.3009994626045227);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 1 ",
                      exp,
                      got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result.val[0], 2);
         exp = ((float32_t) 0.7073160409927368);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 2 ",
                      exp,
                      got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result.val[0], 3);
         exp = ((float32_t) 0.4864059090614319);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 3 ",
                      exp,
                      got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result.val[1], 0);
         exp = ((float32_t) 0.6740353107452393);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 0 ",
                      exp,
                      got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result.val[1], 1);
         exp = ((float32_t) 0.8414262533187866);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 1 ",
                      exp,
                      got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result.val[1], 2);
         exp = ((float32_t) 0.554280161857605);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 2 ",
                      exp,
                      got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result.val[1], 3);
         exp = ((float32_t) 0.4461796283721924);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 3 ",
                      exp,
                      got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result.val[2], 0);
         exp = ((float32_t) 0.5906755924224854);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 2 Lane 0 ",
                      exp,
                      got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result.val[2], 1);
         exp = ((float32_t) 0.46078211069107056);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 2 Lane 1 ",
                      exp,
                      got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result.val[2], 2);
         exp = ((float32_t) 0.7118404507637024);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 2 Lane 2 ",
                      exp,
                      got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result.val[2], 3);
         exp = ((float32_t) 0.16086608171463013);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 2 Lane 3 ",
                      exp,
                      got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result.val[3], 0);
         exp = ((float32_t) 0.8822932243347168);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 3 Lane 0 ",
                      exp,
                      got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result.val[3], 1);
         exp = ((float32_t) 0.4035298824310303);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 3 Lane 1 ",
                      exp,
                      got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result.val[3], 2);
         exp = ((float32_t) 0.9445391893386841);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 3 Lane 2 ",
                      exp,
                      got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result.val[3], 3);
         exp = ((float32_t) 0.46389079093933105);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 3 Lane 3 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1387() {

{
   {
      float64_t arg1[8];
      float64x2x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"load4\", fnname = \"vld4q_f64\", rettype = \"float64x2x4_t\", argtypes = \"[__transfersize(8) float64_t const *]\", vals = [PtrVal [FloatVal 0.22409415724093373,FloatVal 0.9658472850272478,FloatVal 0.5146692093667481,FloatVal 0.4927651584004914,FloatVal 0.20460538778795878,FloatVal 0.7765665896555024,FloatVal 0.28090092973156866,FloatVal 0.7873387330394457]], start_saturated = False}";
      int reported = 0;
      arg1[0] = 0.22409415724093373;
      arg1[1] = 0.9658472850272478;
      arg1[2] = 0.5146692093667481;
      arg1[3] = 0.4927651584004914;
      arg1[4] = 0.20460538778795878;
      arg1[5] = 0.7765665896555024;
      arg1[6] = 0.28090092973156866;
      arg1[7] = 0.7873387330394457;
      clear_neon_saturated();
      //  Expect: "result" = 3fe931e0ffa8e96c3fdf8976dffc0e423fd1fa47e4a73cba3fe0782b8fcfa0a53fe8d9a22d3792833feee83890c3eadd3fca308264913d383fccaf1e0a4988f4
      result = vld4q_f64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float64_t got;
         float64_t exp;
         got = vgetq_lane_f64(result.val[0], 0);
         exp = 0.22409415724093373;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 0 ",
                      exp,
                      got);
            }
      }
      {
         float64_t got;
         float64_t exp;
         got = vgetq_lane_f64(result.val[0], 1);
         exp = 0.20460538778795878;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 1 ",
                      exp,
                      got);
            }
      }
      {
         float64_t got;
         float64_t exp;
         got = vgetq_lane_f64(result.val[1], 0);
         exp = 0.9658472850272478;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 0 ",
                      exp,
                      got);
            }
      }
      {
         float64_t got;
         float64_t exp;
         got = vgetq_lane_f64(result.val[1], 1);
         exp = 0.7765665896555024;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 1 ",
                      exp,
                      got);
            }
      }
      {
         float64_t got;
         float64_t exp;
         got = vgetq_lane_f64(result.val[2], 0);
         exp = 0.5146692093667481;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 2 Lane 0 ",
                      exp,
                      got);
            }
      }
      {
         float64_t got;
         float64_t exp;
         got = vgetq_lane_f64(result.val[2], 1);
         exp = 0.28090092973156866;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 2 Lane 1 ",
                      exp,
                      got);
            }
      }
      {
         float64_t got;
         float64_t exp;
         got = vgetq_lane_f64(result.val[3], 0);
         exp = 0.4927651584004914;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 3 Lane 0 ",
                      exp,
                      got);
            }
      }
      {
         float64_t got;
         float64_t exp;
         got = vgetq_lane_f64(result.val[3], 1);
         exp = 0.7873387330394457;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 3 Lane 1 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1388() {

{
   {
      poly8_t arg1[64];
      poly8x16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"load4\", fnname = \"vld4q_p8\", rettype = \"poly8x16x4_t\", argtypes = \"[__transfersize(64) poly8_t const *]\", vals = [PtrVal [PolyVal [1,0,1,1,0,0,1,1],PolyVal [0,1,1,1,1,0,0,1],PolyVal [1,1,0,1,0,1,1,1],PolyVal [1,0,1,1,0,1,1,0],PolyVal [0,1,1,0,0,1,0,0],PolyVal [0,0,1,0,1,1,0,0],PolyVal [0,0,1,1,1,0,1,0],PolyVal [0,1,1,1,1,1,1,1],PolyVal [0,1,0,0,1,0,1,1],PolyVal [1,0,0,0,0,0,1,0],PolyVal [0,1,0,0,0,0,0,1],PolyVal [1,0,0,0,1,1,1,1],PolyVal [0,1,1,1,0,0,0,1],PolyVal [1,0,1,1,0,0,1,0],PolyVal [1,0,0,1,0,0,1,0],PolyVal [0,0,1,1,0,1,1,1],PolyVal [0,1,1,0,0,1,1,0],PolyVal [0,1,1,1,1,1,1,0],PolyVal [1,0,1,0,0,1,0,0],PolyVal [0,0,1,1,1,0,0,0],PolyVal [1,1,0,0,0,1,0,1],PolyVal [1,0,0,0,0,0,0,0],PolyVal [1,0,0,0,0,0,1,1],PolyVal [0,0,1,0,0,1,1,1],PolyVal [0,1,1,0,1,0,1,1],PolyVal [0,0,0,1,1,0,0,1],PolyVal [1,0,1,1,0,0,0,0],PolyVal [0,1,0,0,1,1,0,0],PolyVal [1,1,1,1,1,1,0,1],PolyVal [1,1,0,0,1,1,1,0],PolyVal [0,1,1,0,1,1,0,0],PolyVal [0,1,1,1,1,1,1,0],PolyVal [1,0,1,0,1,0,0,0],PolyVal [1,0,1,0,1,1,1,1],PolyVal [1,0,0,1,1,1,0,1],PolyVal [1,1,0,1,1,1,1,0],PolyVal [1,0,1,0,1,1,1,1],PolyVal [1,1,0,0,0,1,0,1],PolyVal [1,0,1,1,0,1,0,0],PolyVal [1,0,0,0,1,1,0,0],PolyVal [0,1,0,1,0,1,0,0],PolyVal [1,1,1,1,1,1,1,0],PolyVal [1,0,0,0,1,1,0,1],PolyVal [0,0,1,1,0,1,0,0],PolyVal [0,0,0,0,0,1,0,0],PolyVal [1,0,1,1,1,0,1,0],PolyVal [1,1,1,1,0,0,0,0],PolyVal [1,1,0,1,0,0,0,0],PolyVal [1,0,1,1,1,0,1,0],PolyVal [0,0,0,0,0,0,0,1],PolyVal [1,0,0,0,0,1,0,0],PolyVal [0,0,0,1,1,1,0,1],PolyVal [1,1,1,1,1,1,1,0],PolyVal [0,0,1,1,1,1,1,1],PolyVal [0,0,1,1,1,0,0,0],PolyVal [1,1,1,0,1,0,1,0],PolyVal [1,0,1,0,0,0,1,1],PolyVal [0,1,1,1,1,0,0,0],PolyVal [1,1,0,0,0,0,0,1],PolyVal [1,0,1,0,0,1,0,0],PolyVal [1,1,1,1,0,1,0,0],PolyVal [0,0,0,0,1,1,1,0],PolyVal [0,0,1,1,0,1,1,1],PolyVal [0,0,1,1,0,1,1,1]]], start_saturated = False}";
      int reported = 0;
      arg1[0] = 205;
      arg1[1] = 158;
      arg1[2] = 235;
      arg1[3] = 109;
      arg1[4] = 38;
      arg1[5] = 52;
      arg1[6] = 92;
      arg1[7] = 254;
      arg1[8] = 210;
      arg1[9] = 65;
      arg1[10] = 130;
      arg1[11] = 241;
      arg1[12] = 142;
      arg1[13] = 77;
      arg1[14] = 73;
      arg1[15] = 236;
      arg1[16] = 102;
      arg1[17] = 126;
      arg1[18] = 37;
      arg1[19] = 28;
      arg1[20] = 163;
      arg1[21] = 1;
      arg1[22] = 193;
      arg1[23] = 228;
      arg1[24] = 214;
      arg1[25] = 152;
      arg1[26] = 13;
      arg1[27] = 50;
      arg1[28] = 191;
      arg1[29] = 115;
      arg1[30] = 54;
      arg1[31] = 126;
      arg1[32] = 21;
      arg1[33] = 245;
      arg1[34] = 185;
      arg1[35] = 123;
      arg1[36] = 245;
      arg1[37] = 163;
      arg1[38] = 45;
      arg1[39] = 49;
      arg1[40] = 42;
      arg1[41] = 127;
      arg1[42] = 177;
      arg1[43] = 44;
      arg1[44] = 32;
      arg1[45] = 93;
      arg1[46] = 15;
      arg1[47] = 11;
      arg1[48] = 93;
      arg1[49] = 128;
      arg1[50] = 33;
      arg1[51] = 184;
      arg1[52] = 127;
      arg1[53] = 252;
      arg1[54] = 28;
      arg1[55] = 87;
      arg1[56] = 197;
      arg1[57] = 30;
      arg1[58] = 131;
      arg1[59] = 37;
      arg1[60] = 47;
      arg1[61] = 112;
      arg1[62] = 236;
      arg1[63] = 236;
      clear_neon_saturated();
      //  Expect: "result" = ec2557b80b2c317b7e32e41cecf1fe6dec831c210fb12db9360dc12549825ceb701efc805d7fa3f57398017e4d41349e2fc57f5d202af515bfd6a3668ed226cd
      result = vld4q_p8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p8(result.val[0]), 0);
         exp = UINT64_C(0xbfd6a3668ed226cd);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p8(result.val[0]), 1);
         exp = UINT64_C(0x2fc57f5d202af515);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p8(result.val[1]), 0);
         exp = UINT64_C(0x7398017e4d41349e);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p8(result.val[1]), 1);
         exp = UINT64_C(0x701efc805d7fa3f5);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p8(result.val[2]), 0);
         exp = UINT64_C(0x360dc12549825ceb);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p8(result.val[2]), 1);
         exp = UINT64_C(0xec831c210fb12db9);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p8(result.val[3]), 0);
         exp = UINT64_C(0x7e32e41cecf1fe6d);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 3 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p8(result.val[3]), 1);
         exp = UINT64_C(0xec2557b80b2c317b);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 3 High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1389() {

{
   {
      poly16_t arg1[32];
      poly16x8x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"load4\", fnname = \"vld4q_p16\", rettype = \"poly16x8x4_t\", argtypes = \"[__transfersize(32) poly16_t const *]\", vals = [PtrVal [PolyVal [1,0,0,1,0,0,0,1,0,0,0,1,1,1,0,1],PolyVal [1,0,1,1,0,1,0,0,1,1,0,1,1,1,0,0],PolyVal [0,0,0,1,0,0,0,0,1,0,0,0,1,1,0,1],PolyVal [0,1,0,1,1,0,1,0,1,1,1,0,1,1,0,1],PolyVal [0,1,0,1,0,1,0,1,0,0,0,0,1,0,0,0],PolyVal [1,0,1,0,1,0,0,0,1,0,1,0,1,1,0,0],PolyVal [0,0,1,0,0,1,1,1,1,1,1,0,0,1,1,0],PolyVal [1,1,0,0,1,0,1,0,0,1,0,1,1,1,0,1],PolyVal [0,1,1,1,1,0,1,1,1,1,0,1,0,1,0,1],PolyVal [0,1,1,1,0,1,1,0,1,0,1,1,1,0,1,1],PolyVal [1,0,0,1,1,0,1,0,0,0,1,1,1,0,0,0],PolyVal [1,1,0,1,0,1,0,0,0,0,1,0,1,1,1,0],PolyVal [1,0,1,1,1,1,1,0,1,1,0,1,1,1,1,1],PolyVal [0,0,1,1,1,1,1,1,0,1,0,0,0,0,0,0],PolyVal [1,0,0,0,1,0,0,1,0,0,0,0,1,1,0,1],PolyVal [0,0,1,0,0,0,1,0,0,1,1,0,1,0,1,0],PolyVal [1,0,0,0,0,1,1,1,1,1,1,0,0,0,0,0],PolyVal [0,0,1,0,0,1,0,0,0,0,1,1,1,0,0,0],PolyVal [1,1,0,0,0,1,0,0,1,0,0,0,0,1,1,0],PolyVal [0,1,0,0,0,0,1,1,0,0,0,1,1,1,0,1],PolyVal [0,0,1,1,0,1,0,1,0,1,1,0,1,0,0,1],PolyVal [1,0,1,0,1,1,0,0,1,0,1,0,1,0,0,0],PolyVal [0,0,1,0,0,1,0,0,1,0,1,1,1,1,0,1],PolyVal [0,1,0,1,1,1,1,0,1,0,0,1,1,0,1,1],PolyVal [0,0,1,0,1,1,1,1,0,0,1,0,1,0,0,0],PolyVal [1,0,1,0,1,1,0,0,0,1,1,1,0,0,1,1],PolyVal [0,0,1,0,1,1,1,0,1,1,0,1,1,0,1,1],PolyVal [0,0,0,1,0,1,0,1,1,1,0,0,0,0,0,1],PolyVal [0,1,0,1,0,1,0,0,0,1,0,1,0,0,1,0],PolyVal [0,0,1,1,0,1,1,0,0,1,0,0,0,1,0,1],PolyVal [1,1,0,0,0,0,0,0,1,0,0,1,0,1,0,1],PolyVal [0,0,1,0,1,1,1,0,1,0,0,1,0,1,1,1]]], start_saturated = False}";
      int reported = 0;
      arg1[0] = 47241;
      arg1[1] = 15149;
      arg1[2] = 45320;
      arg1[3] = 46938;
      arg1[4] = 4266;
      arg1[5] = 13589;
      arg1[6] = 26596;
      arg1[7] = 47699;
      arg1[8] = 43998;
      arg1[9] = 56686;
      arg1[10] = 7257;
      arg1[11] = 29739;
      arg1[12] = 64381;
      arg1[13] = 764;
      arg1[14] = 45201;
      arg1[15] = 22084;
      arg1[16] = 2017;
      arg1[17] = 7204;
      arg1[18] = 24867;
      arg1[19] = 47298;
      arg1[20] = 38572;
      arg1[21] = 5429;
      arg1[22] = 48420;
      arg1[23] = 55674;
      arg1[24] = 5364;
      arg1[25] = 52789;
      arg1[26] = 56180;
      arg1[27] = 33704;
      arg1[28] = 18986;
      arg1[29] = 41580;
      arg1[30] = 43267;
      arg1[31] = 59764;
      clear_neon_saturated();
      //  Expect: "result" = e97483a8d97ab8c25644742bba53b75aa903db74bd246123b0911c5967e4b108a26cce3515351c2402fcdd6e35153b2d4a2a14f496ac07e1fb7dabde10aab889
      result = vld4q_p16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p16(result.val[0]), 0);
         exp = UINT64_C(0xfb7dabde10aab889);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p16(result.val[0]), 1);
         exp = UINT64_C(0x4a2a14f496ac07e1);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p16(result.val[1]), 0);
         exp = UINT64_C(0x02fcdd6e35153b2d);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p16(result.val[1]), 1);
         exp = UINT64_C(0xa26cce3515351c24);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p16(result.val[2]), 0);
         exp = UINT64_C(0xb0911c5967e4b108);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p16(result.val[2]), 1);
         exp = UINT64_C(0xa903db74bd246123);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p16(result.val[3]), 0);
         exp = UINT64_C(0x5644742bba53b75a);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 3 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p16(result.val[3]), 1);
         exp = UINT64_C(0xe97483a8d97ab8c2);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 3 High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1390() {
#if __ARM_NEON_FP16_INTRINSICS

{
   {
      __fp16 arg1[32];
      float16x8x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"load4\", fnname = \"vld4q_f16\", rettype = \"float16x8x4_t\", argtypes = \"[__transfersize(32) __fp16 const *]\", vals = [PtrVal [FloatVal (-3.8545187316009084),FloatVal (-2.502784923066179),FloatVal (-8.337405559527205),FloatVal (-6.120670311704517),FloatVal (-8.291905185377056),FloatVal (-6.497012771749442),FloatVal 8.036536728390029,FloatVal (-9.815245542252164),FloatVal (-0.8494556922266696),FloatVal 8.12992292594868,FloatVal (-5.041179470558486),FloatVal 8.24218768309331,FloatVal 6.393820501993524,FloatVal (-2.0568048245557202),FloatVal (-0.9846252555285151),FloatVal 3.142996062530621,FloatVal (-8.196910063765275),FloatVal 5.2593260005496134e-2,FloatVal 9.424879093516608,FloatVal (-1.108725489535825),FloatVal (-5.821892608319928),FloatVal 9.874108742255974,FloatVal (-0.8858973925760516),FloatVal (-7.279266967490708),FloatVal (-8.76971208758504),FloatVal (-6.040920222075085),FloatVal (-7.5466113039137195),FloatVal (-0.5398500663970012),FloatVal (-2.8800010685123496),FloatVal (-8.56738224995171),FloatVal (-9.436298401441102),FloatVal (-3.6205699085688936)]], start_saturated = False}";
      int reported = 0;
      arg1[0] = -3.8545187316009084;
      arg1[1] = -2.502784923066179;
      arg1[2] = -8.337405559527205;
      arg1[3] = -6.120670311704517;
      arg1[4] = -8.291905185377056;
      arg1[5] = -6.497012771749442;
      arg1[6] = 8.036536728390029;
      arg1[7] = -9.815245542252164;
      arg1[8] = -0.8494556922266696;
      arg1[9] = 8.12992292594868;
      arg1[10] = -5.041179470558486;
      arg1[11] = 8.24218768309331;
      arg1[12] = 6.393820501993524;
      arg1[13] = -2.0568048245557202;
      arg1[14] = -0.9846252555285151;
      arg1[15] = 3.142996062530621;
      arg1[16] = -8.196910063765275;
      arg1[17] = 5.2593260005496134e-2;
      arg1[18] = 9.424879093516608;
      arg1[19] = -1.108725489535825;
      arg1[20] = -5.821892608319928;
      arg1[21] = 9.874108742255974;
      arg1[22] = -0.8858973925760516;
      arg1[23] = -7.279266967490708;
      arg1[24] = -8.76971208758504;
      arg1[25] = -6.040920222075085;
      arg1[26] = -7.5466113039137195;
      arg1[27] = -0.5398500663970012;
      arg1[28] = -2.8800010685123496;
      arg1[29] = -8.56738224995171;
      arg1[30] = -9.436298401441102;
      arg1[31] = -3.6205699085688936;
      clear_neon_saturated();
      //  Expect: "result" = c33db851c747bc6f4249481fc8e8c61ec8b7c78bbb1648b6bbe0c50a4804c82bc848c60a48ef2abbc01d4810c67fc101c1c2c862c5d2c8194664bacbc825c3b5
      result = vld4q_f16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[0], 0);
         exp = -3.8545187316009084;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 0 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[0], 1);
         exp = -8.291905185377056;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 1 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[0], 2);
         exp = -0.8494556922266696;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 2 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[0], 3);
         exp = 6.393820501993524;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 3 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[0], 4);
         exp = -8.196910063765275;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 4 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[0], 5);
         exp = -5.821892608319928;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 5 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[0], 6);
         exp = -8.76971208758504;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 6 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[0], 7);
         exp = -2.8800010685123496;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 7 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[1], 0);
         exp = -2.502784923066179;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 0 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[1], 1);
         exp = -6.497012771749442;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 1 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[1], 2);
         exp = 8.12992292594868;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 2 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[1], 3);
         exp = -2.0568048245557202;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 3 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[1], 4);
         exp = 5.2593260005496134e-2;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 4 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[1], 5);
         exp = 9.874108742255974;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 5 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[1], 6);
         exp = -6.040920222075085;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 6 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[1], 7);
         exp = -8.56738224995171;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 7 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[2], 0);
         exp = -8.337405559527205;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 2 Lane 0 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[2], 1);
         exp = 8.036536728390029;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 2 Lane 1 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[2], 2);
         exp = -5.041179470558486;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 2 Lane 2 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[2], 3);
         exp = -0.9846252555285151;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 2 Lane 3 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[2], 4);
         exp = 9.424879093516608;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 2 Lane 4 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[2], 5);
         exp = -0.8858973925760516;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 2 Lane 5 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[2], 6);
         exp = -7.5466113039137195;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 2 Lane 6 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[2], 7);
         exp = -9.436298401441102;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 2 Lane 7 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[3], 0);
         exp = -6.120670311704517;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 3 Lane 0 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[3], 1);
         exp = -9.815245542252164;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 3 Lane 1 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[3], 2);
         exp = 8.24218768309331;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 3 Lane 2 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[3], 3);
         exp = 3.142996062530621;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 3 Lane 3 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[3], 4);
         exp = -1.108725489535825;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 3 Lane 4 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[3], 5);
         exp = -7.279266967490708;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 3 Lane 5 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[3], 6);
         exp = -0.5398500663970012;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 3 Lane 6 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[3], 7);
         exp = -3.6205699085688936;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 3 Lane 7 ",
                      exp,
                      got);
            }
      }
   }
}
#endif
}
void dotests_1391() {

{
   {
      poly64_t arg1[8];
      poly64x2x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"load4\", fnname = \"vld4q_p64\", rettype = \"poly64x2x4_t\", argtypes = \"[__transfersize(8) poly64_t const *]\", vals = [PtrVal [PolyVal [0,1,1,1,1,0,0,1,0,0,0,0,1,1,1,1,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,0,0,0,1,0,1,1,0,1,1,0,0,1,1],PolyVal [1,0,1,1,0,1,0,1,1,0,1,1,0,1,0,1,1,1,1,0,1,0,1,0,1,1,1,0,1,1,0,0,1,1,1,0,1,0,1,1,1,0,1,1,0,0,0,1,1,1,1,1,1,0,0,0,0,1,0,1,1,0,1,1],PolyVal [1,0,0,1,0,0,1,0,1,0,0,0,0,1,1,1,1,0,1,0,1,0,0,0,1,1,1,1,0,1,0,1,0,0,0,0,1,1,1,1,0,0,1,1,0,1,1,0,1,0,1,0,0,1,1,1,0,0,1,1,1,1,1,1],PolyVal [1,0,1,1,1,0,0,0,0,1,1,1,1,1,1,0,1,1,1,1,1,1,1,1,1,0,0,1,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,1,0,1,0,1,1,0,0,1,1,0,0,1,0,0,0,0],PolyVal [0,1,1,1,1,1,0,1,1,0,0,0,1,1,1,0,0,1,1,0,0,0,0,0,0,1,1,0,1,1,1,1,0,0,0,1,1,1,1,1,1,1,1,0,1,0,1,0,0,1,0,0,1,0,0,0,0,1,0,1,0,0,0,1],PolyVal [1,0,1,0,0,0,1,1,1,0,1,1,1,1,1,1,0,1,0,1,1,0,0,0,1,1,1,1,0,1,1,1,1,1,1,1,0,1,1,1,1,1,0,0,1,1,1,0,0,0,1,1,0,0,1,1,0,0,0,0,0,0,0,1],PolyVal [1,0,0,1,0,0,1,1,1,0,0,1,0,0,0,1,1,0,1,0,1,0,1,0,1,0,0,0,1,1,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,1,0,0,1,1,0,1,0],PolyVal [1,1,0,1,1,0,0,1,1,1,0,0,1,1,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,1,1,0,1,1,1,1,0,1,0,0,0,1,1,0,1,1,1,1,0,1,1,1,0,1,1,0,1,1,1,1,0,0,0,0]]], start_saturated = False}";
      int reported = 0;
      arg1[0] = -3628792940246732642;
      arg1[1] = -2729306893677253203;
      arg1[2] = -223652825499573943;
      arg1[3] = 692023970773302813;
      arg1[4] = -8497632820103581250;
      arg1[5] = -9165823667259900475;
      arg1[6] = 6422314661749033417;
      arg1[7] = 1112096841392010139;
      clear_neon_saturated();
      //  Expect: "result" = 0f6ef62f6301339b099a902289ff7e1d5920a528715589c9fce56cf0af15e14980cc73efef1afdc5da1f8dd73757adad8a1257f8f60671becda3f00c0925f09e
      result = vld4q_p64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p64(result.val[0]), 0);
         exp = UINT64_C(0xcda3f00c0925f09e);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p64(result.val[0]), 1);
         exp = UINT64_C(0x8a1257f8f60671be);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p64(result.val[1]), 0);
         exp = UINT64_C(0xda1f8dd73757adad);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p64(result.val[1]), 1);
         exp = UINT64_C(0x80cc73efef1afdc5);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p64(result.val[2]), 0);
         exp = UINT64_C(0xfce56cf0af15e149);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p64(result.val[2]), 1);
         exp = UINT64_C(0x5920a528715589c9);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p64(result.val[3]), 0);
         exp = UINT64_C(0x099a902289ff7e1d);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 3 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p64(result.val[3]), 1);
         exp = UINT64_C(0x0f6ef62f6301339b);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 3 High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1392() {

{
   {
      uint8_t arg1[32];
      uint8x8x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"load4\", fnname = \"vld4_u8\", rettype = \"uint8x8x4_t\", argtypes = \"[__transfersize(32) uint8_t const *]\", vals = [PtrVal [IntegerVal 128,IntegerVal 229,IntegerVal 128,IntegerVal 255,IntegerVal 255,IntegerVal 255,IntegerVal 89,IntegerVal 128,IntegerVal 0,IntegerVal 128,IntegerVal 199,IntegerVal 255,IntegerVal 158,IntegerVal 255,IntegerVal 240,IntegerVal 255,IntegerVal 127,IntegerVal 213,IntegerVal 128,IntegerVal 37,IntegerVal 0,IntegerVal 0,IntegerVal 32,IntegerVal 255,IntegerVal 202,IntegerVal 255,IntegerVal 254,IntegerVal 127,IntegerVal 0,IntegerVal 123,IntegerVal 128,IntegerVal 127]], start_saturated = False}";
      int reported = 0;
      arg1[0] = 128U;
      arg1[1] = 229U;
      arg1[2] = 128U;
      arg1[3] = 255U;
      arg1[4] = 255U;
      arg1[5] = 255U;
      arg1[6] = 89U;
      arg1[7] = 128U;
      arg1[8] = 0;
      arg1[9] = 128U;
      arg1[10] = 199U;
      arg1[11] = 255U;
      arg1[12] = 158U;
      arg1[13] = 255U;
      arg1[14] = 240U;
      arg1[15] = 255U;
      arg1[16] = 127U;
      arg1[17] = 213U;
      arg1[18] = 128U;
      arg1[19] = 37U;
      arg1[20] = 0;
      arg1[21] = 0;
      arg1[22] = 32U;
      arg1[23] = 255U;
      arg1[24] = 202U;
      arg1[25] = 255U;
      arg1[26] = 254U;
      arg1[27] = 127U;
      arg1[28] = 0;
      arg1[29] = 123U;
      arg1[30] = 128U;
      arg1[31] = 127U;
      clear_neon_saturated();
      //  Expect: "result" = 7f7fff25ffff80ff80fe2080f0c759807bff00d5ff80ffe500ca007f9e00ff80
      result = vld4_u8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_u8(result.val[0]), 0);
         exp = UINT64_C(0x00ca007f9e00ff80);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_u8(result.val[1]), 0);
         exp = UINT64_C(0x7bff00d5ff80ffe5);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_u8(result.val[2]), 0);
         exp = UINT64_C(0x80fe2080f0c75980);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_u8(result.val[3]), 0);
         exp = UINT64_C(0x7f7fff25ffff80ff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 3 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1393() {

{
   {
      uint16_t arg1[16];
      uint16x4x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"load4\", fnname = \"vld4_u16\", rettype = \"uint16x4x4_t\", argtypes = \"[__transfersize(16) uint16_t const *]\", vals = [PtrVal [IntegerVal 44793,IntegerVal 56220,IntegerVal 32767,IntegerVal 65535,IntegerVal 0,IntegerVal 32768,IntegerVal 65535,IntegerVal 0,IntegerVal 32768,IntegerVal 32768,IntegerVal 0,IntegerVal 26984,IntegerVal 15075,IntegerVal 0,IntegerVal 32768,IntegerVal 0]], start_saturated = False}";
      int reported = 0;
      arg1[0] = 44793U;
      arg1[1] = 56220U;
      arg1[2] = 32767U;
      arg1[3] = 65535U;
      arg1[4] = 0;
      arg1[5] = 32768U;
      arg1[6] = 65535U;
      arg1[7] = 0;
      arg1[8] = 32768U;
      arg1[9] = 32768U;
      arg1[10] = 0;
      arg1[11] = 26984U;
      arg1[12] = 15075U;
      arg1[13] = 0;
      arg1[14] = 32768U;
      arg1[15] = 0;
      clear_neon_saturated();
      //  Expect: "result" = 000069680000ffff80000000ffff7fff000080008000db9c3ae380000000aef9
      result = vld4_u16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_u16(result.val[0]), 0);
         exp = UINT64_C(0x3ae380000000aef9);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_u16(result.val[1]), 0);
         exp = UINT64_C(0x000080008000db9c);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_u16(result.val[2]), 0);
         exp = UINT64_C(0x80000000ffff7fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_u16(result.val[3]), 0);
         exp = UINT64_C(0x000069680000ffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 3 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1394() {

{
   {
      uint32_t arg1[8];
      uint32x2x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"load4\", fnname = \"vld4_u32\", rettype = \"uint32x2x4_t\", argtypes = \"[__transfersize(8) uint32_t const *]\", vals = [PtrVal [IntegerVal 2147483647,IntegerVal 2147516416,IntegerVal 4294934528,IntegerVal 2147483647,IntegerVal 2147418112,IntegerVal 4294959744,IntegerVal 4294954543,IntegerVal 2147516416]], start_saturated = False}";
      int reported = 0;
      arg1[0] = 2147483647U;
      arg1[1] = 2147516416U;
      arg1[2] = 4294934528U;
      arg1[3] = 2147483647U;
      arg1[4] = 2147418112U;
      arg1[5] = 4294959744U;
      arg1[6] = 4294954543U;
      arg1[7] = 2147516416U;
      clear_neon_saturated();
      //  Expect: "result" = 800080007fffffffffffce2fffff8000ffffe280800080007fff00007fffffff
      result = vld4_u32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_u32(result.val[0]), 0);
         exp = UINT64_C(0x7fff00007fffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_u32(result.val[1]), 0);
         exp = UINT64_C(0xffffe28080008000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_u32(result.val[2]), 0);
         exp = UINT64_C(0xffffce2fffff8000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_u32(result.val[3]), 0);
         exp = UINT64_C(0x800080007fffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 3 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1395() {

{
   {
      uint64_t arg1[4];
      uint64x1x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"load4\", fnname = \"vld4_u64\", rettype = \"uint64x1x4_t\", argtypes = \"[__transfersize(4) uint64_t const *]\", vals = [PtrVal [IntegerVal 140733193388032,IntegerVal 18446744071562133503,IntegerVal 18446744071562035199,IntegerVal 2856408061512203648]], start_saturated = True}";
      int reported = 0;
      arg1[0] = UINT64_C(0x00007fff00000000);
      arg1[1] = UINT64_C(0xffffffff8000ffff);
      arg1[2] = UINT64_C(0xffffffff7fff7fff);
      arg1[3] = UINT64_C(0x27a3ffff7fff3d80);
      set_neon_saturated();
      //  Expect: "result" = 27a3ffff7fff3d80ffffffff7fff7fffffffffff8000ffff00007fff00000000
      result = vld4_u64(arg1);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(result.val[0], 0);
         exp = UINT64_C(0x00007fff00000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(result.val[1], 0);
         exp = UINT64_C(0xffffffff8000ffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(result.val[2], 0);
         exp = UINT64_C(0xffffffff7fff7fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(result.val[3], 0);
         exp = UINT64_C(0x27a3ffff7fff3d80);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 3 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1396() {

{
   {
      int8_t arg1[32];
      int8x8x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"load4\", fnname = \"vld4_s8\", rettype = \"int8x8x4_t\", argtypes = \"[__transfersize(32) int8_t const *]\", vals = [PtrVal [IntegerVal (-128),IntegerVal (-1),IntegerVal 19,IntegerVal (-122),IntegerVal 0,IntegerVal 127,IntegerVal (-128),IntegerVal 0,IntegerVal (-1),IntegerVal (-128),IntegerVal 127,IntegerVal (-1),IntegerVal 0,IntegerVal (-128),IntegerVal (-1),IntegerVal (-82),IntegerVal 117,IntegerVal 0,IntegerVal (-128),IntegerVal (-1),IntegerVal 56,IntegerVal (-1),IntegerVal 127,IntegerVal (-1),IntegerVal 127,IntegerVal 127,IntegerVal 127,IntegerVal (-128),IntegerVal 127,IntegerVal 127,IntegerVal 127,IntegerVal (-93)]], start_saturated = False}";
      int reported = 0;
      arg1[0] = -128;
      arg1[1] = -1;
      arg1[2] = 19;
      arg1[3] = -122;
      arg1[4] = 0;
      arg1[5] = 127;
      arg1[6] = -128;
      arg1[7] = 0;
      arg1[8] = -1;
      arg1[9] = -128;
      arg1[10] = 127;
      arg1[11] = -1;
      arg1[12] = 0;
      arg1[13] = -128;
      arg1[14] = -1;
      arg1[15] = -82;
      arg1[16] = 117;
      arg1[17] = 0;
      arg1[18] = -128;
      arg1[19] = -1;
      arg1[20] = 56;
      arg1[21] = -1;
      arg1[22] = 127;
      arg1[23] = -1;
      arg1[24] = 127;
      arg1[25] = 127;
      arg1[26] = 127;
      arg1[27] = -128;
      arg1[28] = 127;
      arg1[29] = 127;
      arg1[30] = 127;
      arg1[31] = -93;
      clear_neon_saturated();
      //  Expect: "result" = a380ffffaeff00867f7f7f80ff7f80137f7fff0080807fff7f7f387500ff0080
      result = vld4_s8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_s8(result.val[0]), 0);
         exp = UINT64_C(0x7f7f387500ff0080);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_s8(result.val[1]), 0);
         exp = UINT64_C(0x7f7fff0080807fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_s8(result.val[2]), 0);
         exp = UINT64_C(0x7f7f7f80ff7f8013);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_s8(result.val[3]), 0);
         exp = UINT64_C(0xa380ffffaeff0086);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 3 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1397() {

{
   {
      int16_t arg1[16];
      int16x4x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"load4\", fnname = \"vld4_s16\", rettype = \"int16x4x4_t\", argtypes = \"[__transfersize(16) int16_t const *]\", vals = [PtrVal [IntegerVal (-32768),IntegerVal (-11353),IntegerVal 32767,IntegerVal (-20592),IntegerVal 32767,IntegerVal 32767,IntegerVal (-27405),IntegerVal (-1),IntegerVal (-32768),IntegerVal (-1),IntegerVal 29613,IntegerVal 0,IntegerVal 30830,IntegerVal (-19824),IntegerVal (-32768),IntegerVal 13594]], start_saturated = False}";
      int reported = 0;
      arg1[0] = -32768;
      arg1[1] = -11353;
      arg1[2] = 32767;
      arg1[3] = -20592;
      arg1[4] = 32767;
      arg1[5] = 32767;
      arg1[6] = -27405;
      arg1[7] = -1;
      arg1[8] = -32768;
      arg1[9] = -1;
      arg1[10] = 29613;
      arg1[11] = 0;
      arg1[12] = 30830;
      arg1[13] = -19824;
      arg1[14] = -32768;
      arg1[15] = 13594;
      clear_neon_saturated();
      //  Expect: "result" = 351a0000ffffaf90800073ad94f37fffb290ffff7fffd3a7786e80007fff8000
      result = vld4_s16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_s16(result.val[0]), 0);
         exp = UINT64_C(0x786e80007fff8000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_s16(result.val[1]), 0);
         exp = UINT64_C(0xb290ffff7fffd3a7);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_s16(result.val[2]), 0);
         exp = UINT64_C(0x800073ad94f37fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_s16(result.val[3]), 0);
         exp = UINT64_C(0x351a0000ffffaf90);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 3 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1398() {

{
   {
      int32_t arg1[8];
      int32x2x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"load4\", fnname = \"vld4_s32\", rettype = \"int32x2x4_t\", argtypes = \"[__transfersize(8) int32_t const *]\", vals = [PtrVal [IntegerVal (-2147450881),IntegerVal (-32768),IntegerVal (-1206517760),IntegerVal 65535,IntegerVal 2147457181,IntegerVal 57179,IntegerVal 0,IntegerVal (-32768)]], start_saturated = False}";
      int reported = 0;
      arg1[0] = -2147450881;
      arg1[1] = -32768;
      arg1[2] = -1206517760;
      arg1[3] = 65535;
      arg1[4] = 2147457181;
      arg1[5] = 57179;
      arg1[6] = 0;
      arg1[7] = -32768;
      clear_neon_saturated();
      //  Expect: "result" = ffff80000000ffff00000000b81600000000df5bffff80007fff989d80007fff
      result = vld4_s32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_s32(result.val[0]), 0);
         exp = UINT64_C(0x7fff989d80007fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_s32(result.val[1]), 0);
         exp = UINT64_C(0x0000df5bffff8000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_s32(result.val[2]), 0);
         exp = UINT64_C(0x00000000b8160000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_s32(result.val[3]), 0);
         exp = UINT64_C(0xffff80000000ffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 3 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1399() {

{
   {
      int64_t arg1[4];
      int64x1x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"load4\", fnname = \"vld4_s64\", rettype = \"int64x1x4_t\", argtypes = \"[__transfersize(4) int64_t const *]\", vals = [PtrVal [IntegerVal (-9223362744693096448),IntegerVal 9223099817532522496,IntegerVal (-9223231301513838593),IntegerVal (-2147549184)]], start_saturated = False}";
      int reported = 0;
      arg1[0] = INT64_C(-9223362744693096448);
      arg1[1] = INT64_C(9223099817532522496);
      arg1[2] = INT64_C(-9223231301513838593);
      arg1[3] = INT64_C(-2147549184);
      clear_neon_saturated();
      //  Expect: "result" = ffffffff7fff000080007fff8000ffff7fff086affff0000800008737fff0000
      result = vld4_s64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_s64(result.val[0]), 0);
         exp = UINT64_C(0x800008737fff0000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_s64(result.val[1]), 0);
         exp = UINT64_C(0x7fff086affff0000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_s64(result.val[2]), 0);
         exp = UINT64_C(0x80007fff8000ffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_s64(result.val[3]), 0);
         exp = UINT64_C(0xffffffff7fff0000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 3 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1400() {

{
   {
      float32_t arg1[8];
      float32x2x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"load4\", fnname = \"vld4_f32\", rettype = \"float32x2x4_t\", argtypes = \"[__transfersize(8) float32_t const *]\", vals = [PtrVal [FloatVal 0.2220413088798523,FloatVal 0.5849591493606567,FloatVal 5.056947469711304e-2,FloatVal 0.7764240503311157,FloatVal 0.7151392698287964,FloatVal 0.33886486291885376,FloatVal 8.276468515396118e-2,FloatVal 0.5255247354507446]], start_saturated = False}";
      int reported = 0;
      arg1[0] = ((float32_t) 0.2220413088798523);
      arg1[1] = ((float32_t) 0.5849591493606567);
      arg1[2] = ((float32_t) 5.056947469711304e-2);
      arg1[3] = ((float32_t) 0.7764240503311157);
      arg1[4] = ((float32_t) 0.7151392698287964);
      arg1[5] = ((float32_t) 0.33886486291885376);
      arg1[6] = ((float32_t) 8.276468515396118e-2);
      arg1[7] = ((float32_t) 0.5255247354507446);
      clear_neon_saturated();
      //  Expect: "result" = 3f0688ca3f46c3ba3da980883d4f21f03ead7fb23f15bfe23f37135e3e635ecc
      result = vld4_f32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result.val[0], 0);
         exp = ((float32_t) 0.2220413088798523);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 0 ",
                      exp,
                      got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result.val[0], 1);
         exp = ((float32_t) 0.7151392698287964);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 1 ",
                      exp,
                      got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result.val[1], 0);
         exp = ((float32_t) 0.5849591493606567);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 0 ",
                      exp,
                      got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result.val[1], 1);
         exp = ((float32_t) 0.33886486291885376);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 1 ",
                      exp,
                      got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result.val[2], 0);
         exp = ((float32_t) 5.056947469711304e-2);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 2 Lane 0 ",
                      exp,
                      got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result.val[2], 1);
         exp = ((float32_t) 8.276468515396118e-2);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 2 Lane 1 ",
                      exp,
                      got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result.val[3], 0);
         exp = ((float32_t) 0.7764240503311157);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 3 Lane 0 ",
                      exp,
                      got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result.val[3], 1);
         exp = ((float32_t) 0.5255247354507446);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 3 Lane 1 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1401() {

{
   {
      float64_t arg1[4];
      float64x1x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"load4\", fnname = \"vld4_f64\", rettype = \"float64x1x4_t\", argtypes = \"[__transfersize(4) float64_t const *]\", vals = [PtrVal [FloatVal 0.9325350442029423,FloatVal 0.18239802523846338,FloatVal 0.6295120668234421,FloatVal 0.9134178512475838]], start_saturated = False}";
      int reported = 0;
      arg1[0] = 0.9325350442029423;
      arg1[1] = 0.18239802523846338;
      arg1[2] = 0.6295120668234421;
      arg1[3] = 0.9134178512475838;
      clear_neon_saturated();
      //  Expect: "result" = 3fed3ab812d61c633fe424f67d6e35a93fc758d188a089103fedd753bba737b8
      result = vld4_f64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float64_t got;
         float64_t exp;
         got = vget_lane_f64(result.val[0], 0);
         exp = 0.9325350442029423;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 0 ",
                      exp,
                      got);
            }
      }
      {
         float64_t got;
         float64_t exp;
         got = vget_lane_f64(result.val[1], 0);
         exp = 0.18239802523846338;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 0 ",
                      exp,
                      got);
            }
      }
      {
         float64_t got;
         float64_t exp;
         got = vget_lane_f64(result.val[2], 0);
         exp = 0.6295120668234421;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 2 Lane 0 ",
                      exp,
                      got);
            }
      }
      {
         float64_t got;
         float64_t exp;
         got = vget_lane_f64(result.val[3], 0);
         exp = 0.9134178512475838;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 3 Lane 0 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1402() {

{
   {
      poly8_t arg1[32];
      poly8x8x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"load4\", fnname = \"vld4_p8\", rettype = \"poly8x8x4_t\", argtypes = \"[__transfersize(32) poly8_t const *]\", vals = [PtrVal [PolyVal [0,1,0,1,0,1,0,0],PolyVal [1,0,0,1,0,1,1,1],PolyVal [0,1,1,0,0,0,1,1],PolyVal [0,0,0,0,0,1,1,1],PolyVal [0,1,1,1,0,1,0,0],PolyVal [1,0,1,1,1,1,0,1],PolyVal [1,1,1,1,1,0,1,0],PolyVal [1,0,0,0,0,0,1,0],PolyVal [0,0,1,1,1,1,1,0],PolyVal [0,0,1,0,0,0,1,0],PolyVal [1,1,1,1,0,1,0,0],PolyVal [0,0,1,1,1,1,1,1],PolyVal [1,0,1,1,0,0,0,1],PolyVal [1,0,0,0,1,1,1,0],PolyVal [1,0,0,0,1,1,1,0],PolyVal [0,0,0,0,0,0,0,1],PolyVal [0,1,1,0,1,1,1,1],PolyVal [0,0,0,0,1,0,0,0],PolyVal [1,1,1,1,0,1,0,1],PolyVal [1,1,0,1,1,0,0,0],PolyVal [0,0,0,1,0,0,0,1],PolyVal [1,0,1,1,0,0,1,1],PolyVal [1,1,0,1,0,0,0,0],PolyVal [1,1,1,0,1,1,0,0],PolyVal [0,0,0,1,0,1,0,0],PolyVal [0,1,0,1,1,0,0,1],PolyVal [1,0,0,0,0,1,1,0],PolyVal [1,0,0,1,1,0,1,0],PolyVal [1,1,0,0,1,0,1,0],PolyVal [1,0,1,1,0,0,0,1],PolyVal [0,0,0,1,1,0,0,1],PolyVal [0,1,0,1,0,1,1,1]]], start_saturated = False}";
      int reported = 0;
      arg1[0] = 42;
      arg1[1] = 233;
      arg1[2] = 198;
      arg1[3] = 224;
      arg1[4] = 46;
      arg1[5] = 189;
      arg1[6] = 95;
      arg1[7] = 65;
      arg1[8] = 124;
      arg1[9] = 68;
      arg1[10] = 47;
      arg1[11] = 252;
      arg1[12] = 141;
      arg1[13] = 113;
      arg1[14] = 113;
      arg1[15] = 128;
      arg1[16] = 246;
      arg1[17] = 16;
      arg1[18] = 175;
      arg1[19] = 27;
      arg1[20] = 136;
      arg1[21] = 205;
      arg1[22] = 11;
      arg1[23] = 55;
      arg1[24] = 40;
      arg1[25] = 154;
      arg1[26] = 97;
      arg1[27] = 89;
      arg1[28] = 83;
      arg1[29] = 141;
      arg1[30] = 152;
      arg1[31] = 234;
      clear_neon_saturated();
      //  Expect: "result" = ea59371b80fc41e098610baf712f5fc68d9acd107144bde9532888f68d7c2e2a
      result = vld4_p8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_p8(result.val[0]), 0);
         exp = UINT64_C(0x532888f68d7c2e2a);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_p8(result.val[1]), 0);
         exp = UINT64_C(0x8d9acd107144bde9);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_p8(result.val[2]), 0);
         exp = UINT64_C(0x98610baf712f5fc6);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_p8(result.val[3]), 0);
         exp = UINT64_C(0xea59371b80fc41e0);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 3 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1403() {

{
   {
      poly16_t arg1[16];
      poly16x4x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"load4\", fnname = \"vld4_p16\", rettype = \"poly16x4x4_t\", argtypes = \"[__transfersize(16) poly16_t const *]\", vals = [PtrVal [PolyVal [0,0,0,1,0,1,0,0,0,1,0,0,0,0,1,1],PolyVal [1,0,1,0,0,0,1,1,0,0,0,1,0,0,1,1],PolyVal [1,1,1,1,0,0,0,0,0,1,1,1,0,1,0,1],PolyVal [1,0,1,0,1,1,0,0,0,1,0,0,0,1,0,0],PolyVal [1,0,1,1,0,0,0,1,0,0,1,1,0,1,0,0],PolyVal [1,1,0,1,1,0,0,1,0,0,0,0,1,0,0,0],PolyVal [0,1,0,1,1,0,1,0,1,1,1,1,0,1,1,0],PolyVal [0,1,1,0,1,1,1,0,1,1,0,1,1,1,1,0],PolyVal [1,1,1,1,0,0,0,0,0,0,1,0,1,1,0,0],PolyVal [1,0,1,0,1,1,1,1,0,1,0,0,1,0,0,0],PolyVal [1,0,1,0,0,1,0,1,1,1,0,0,0,1,0,0],PolyVal [0,0,1,1,0,0,1,0,0,1,1,0,0,0,1,1],PolyVal [1,0,0,1,1,0,1,1,0,0,1,1,0,1,0,1],PolyVal [1,0,0,0,0,1,0,1,1,1,0,0,0,0,0,1],PolyVal [1,1,0,1,1,0,0,1,1,1,1,1,1,1,1,1],PolyVal [1,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0]]], start_saturated = False}";
      int reported = 0;
      arg1[0] = 49704;
      arg1[1] = 51397;
      arg1[2] = 44559;
      arg1[3] = 8757;
      arg1[4] = 11405;
      arg1[5] = 4251;
      arg1[6] = 28506;
      arg1[7] = 31606;
      arg1[8] = 13327;
      arg1[9] = 4853;
      arg1[10] = 9125;
      arg1[11] = 50764;
      arg1[12] = 44249;
      arg1[13] = 33697;
      arg1[14] = 65435;
      arg1[15] = 53;
      clear_neon_saturated();
      //  Expect: "result" = 0035c64c7b762235ff9b23a56f5aae0f83a112f5109bc8c5acd9340f2c8dc228
      result = vld4_p16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_p16(result.val[0]), 0);
         exp = UINT64_C(0xacd9340f2c8dc228);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_p16(result.val[1]), 0);
         exp = UINT64_C(0x83a112f5109bc8c5);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_p16(result.val[2]), 0);
         exp = UINT64_C(0xff9b23a56f5aae0f);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_p16(result.val[3]), 0);
         exp = UINT64_C(0x0035c64c7b762235);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 3 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1404() {
#if __ARM_NEON_FP16_INTRINSICS

{
   {
      __fp16 arg1[16];
      float16x4x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"load4\", fnname = \"vld4_f16\", rettype = \"float16x4x4_t\", argtypes = \"[__transfersize(16) __fp16 const *]\", vals = [PtrVal [FloatVal (-9.564409043321792),FloatVal 9.207932487454684,FloatVal 5.830457558641346,FloatVal (-3.8866267685258693),FloatVal (-2.092078243439923),FloatVal 1.431613403338467,FloatVal (-6.561277301862704),FloatVal 3.5625215716167453,FloatVal 7.275306702489928,FloatVal 3.4369849307531943,FloatVal 9.076536054433998,FloatVal 5.120811297725483,FloatVal (-2.855221380210134),FloatVal 7.891171993989534,FloatVal (-3.1370268842445626),FloatVal (-7.865105640530119)]], start_saturated = False}";
      int reported = 0;
      arg1[0] = -9.564409043321792;
      arg1[1] = 9.207932487454684;
      arg1[2] = 5.830457558641346;
      arg1[3] = -3.8866267685258693;
      arg1[4] = -2.092078243439923;
      arg1[5] = 1.431613403338467;
      arg1[6] = -6.561277301862704;
      arg1[7] = 3.5625215716167453;
      arg1[8] = 7.275306702489928;
      arg1[9] = 3.4369849307531943;
      arg1[10] = 9.076536054433998;
      arg1[11] = 5.120811297725483;
      arg1[12] = -2.855221380210134;
      arg1[13] = 7.891171993989534;
      arg1[14] = -3.1370268842445626;
      arg1[15] = -7.865105640530119;
      clear_neon_saturated();
      //  Expect: "result" = c7dd451e4320c3c5c2464889c68f45d447e442df3db9489ac1b54746c02fc8c8
      result = vld4_f16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         __fp16 got;
         __fp16 exp;
         got = vget_lane_f16(result.val[0], 0);
         exp = -9.564409043321792;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 0 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vget_lane_f16(result.val[0], 1);
         exp = -2.092078243439923;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 1 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vget_lane_f16(result.val[0], 2);
         exp = 7.275306702489928;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 2 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vget_lane_f16(result.val[0], 3);
         exp = -2.855221380210134;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 3 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vget_lane_f16(result.val[1], 0);
         exp = 9.207932487454684;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 0 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vget_lane_f16(result.val[1], 1);
         exp = 1.431613403338467;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 1 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vget_lane_f16(result.val[1], 2);
         exp = 3.4369849307531943;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 2 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vget_lane_f16(result.val[1], 3);
         exp = 7.891171993989534;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 3 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vget_lane_f16(result.val[2], 0);
         exp = 5.830457558641346;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 2 Lane 0 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vget_lane_f16(result.val[2], 1);
         exp = -6.561277301862704;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 2 Lane 1 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vget_lane_f16(result.val[2], 2);
         exp = 9.076536054433998;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 2 Lane 2 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vget_lane_f16(result.val[2], 3);
         exp = -3.1370268842445626;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 2 Lane 3 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vget_lane_f16(result.val[3], 0);
         exp = -3.8866267685258693;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 3 Lane 0 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vget_lane_f16(result.val[3], 1);
         exp = 3.5625215716167453;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 3 Lane 1 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vget_lane_f16(result.val[3], 2);
         exp = 5.120811297725483;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 3 Lane 2 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vget_lane_f16(result.val[3], 3);
         exp = -7.865105640530119;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 3 Lane 3 ",
                      exp,
                      got);
            }
      }
   }
}
#endif
}
void dotests_1405() {

{
   {
      poly64_t arg1[4];
      poly64x1x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"load4\", fnname = \"vld4_p64\", rettype = \"poly64x1x4_t\", argtypes = \"[__transfersize(4) poly64_t const *]\", vals = [PtrVal [PolyVal [1,0,1,1,1,1,1,0,1,0,1,1,0,1,0,1,1,0,1,0,1,1,0,0,0,1,0,0,0,0,0,1,0,1,0,0,1,1,1,0,1,1,1,0,1,1,1,1,1,1,0,0,0,1,0,1,1,1,1,0,0,1,0,0],PolyVal [1,0,0,1,1,0,0,1,1,1,1,1,1,0,1,1,0,1,0,0,1,1,1,1,1,1,1,1,0,1,1,1,0,0,1,1,1,0,0,1,0,1,0,0,0,1,0,1,1,1,1,1,0,0,0,0,0,0,1,0,1,0,0,0],PolyVal [0,1,0,0,0,1,1,1,0,0,1,1,1,1,0,1,0,1,1,1,1,0,1,1,0,0,1,0,1,1,0,0,0,0,0,1,0,0,1,0,0,0,1,1,1,1,0,0,0,0,1,1,0,0,1,0,1,1,1,1,1,1,0,1],PolyVal [0,1,1,0,1,0,1,1,0,1,0,1,0,0,0,0,1,1,0,1,1,1,1,0,1,1,1,1,0,1,1,0,0,0,0,0,0,1,0,1,0,0,1,1,0,0,0,0,1,1,0,1,0,1,1,0,0,1,0,1,0,1,1,1]]], start_saturated = False}";
      int reported = 0;
      arg1[0] = 2856398659865914749;
      arg1[1] = 1445552800333488025;
      arg1[2] = -4662285233412981534;
      arg1[3] = -1555135363121739050;
      clear_neon_saturated();
      //  Expect: "result" = ea6b0ca06f7b0ad6bf4c3c4834debce2140fa29ceff2df9927a3f7728235ad7d
      result = vld4_p64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_p64(result.val[0]), 0);
         exp = UINT64_C(0x27a3f7728235ad7d);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_p64(result.val[1]), 0);
         exp = UINT64_C(0x140fa29ceff2df99);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_p64(result.val[2]), 0);
         exp = UINT64_C(0xbf4c3c4834debce2);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_p64(result.val[3]), 0);
         exp = UINT64_C(0xea6b0ca06f7b0ad6);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 3 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1406() {

{
   {
      uint8_t arg1[2];
      uint8x8x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"load2_alllanes\", fnname = \"vld2_dup_u8\", rettype = \"uint8x8x2_t\", argtypes = \"[__transfersize(2) uint8_t const *]\", vals = [PtrVal [IntegerVal 71,IntegerVal 128]], start_saturated = False}";
      int reported = 0;
      arg1[0] = 71U;
      arg1[1] = 128U;
      clear_neon_saturated();
      //  Expect: "result" = 80808080808080804747474747474747
      result = vld2_dup_u8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_u8(result.val[0]), 0);
         exp = UINT64_C(0x4747474747474747);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_u8(result.val[1]), 0);
         exp = UINT64_C(0x8080808080808080);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1407() {

{
   {
      uint16_t arg1[2];
      uint16x4x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"load2_alllanes\", fnname = \"vld2_dup_u16\", rettype = \"uint16x4x2_t\", argtypes = \"[__transfersize(2) uint16_t const *]\", vals = [PtrVal [IntegerVal 32767,IntegerVal 65535]], start_saturated = False}";
      int reported = 0;
      arg1[0] = 32767U;
      arg1[1] = 65535U;
      clear_neon_saturated();
      //  Expect: "result" = ffffffffffffffff7fff7fff7fff7fff
      result = vld2_dup_u16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_u16(result.val[0]), 0);
         exp = UINT64_C(0x7fff7fff7fff7fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_u16(result.val[1]), 0);
         exp = UINT64_C(0xffffffffffffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1408() {

{
   {
      uint32_t arg1[2];
      uint32x2x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"load2_alllanes\", fnname = \"vld2_dup_u32\", rettype = \"uint32x2x2_t\", argtypes = \"[__transfersize(2) uint32_t const *]\", vals = [PtrVal [IntegerVal 2147473690,IntegerVal 2147516416]], start_saturated = False}";
      int reported = 0;
      arg1[0] = 2147473690U;
      arg1[1] = 2147516416U;
      clear_neon_saturated();
      //  Expect: "result" = 80008000800080007fffd91a7fffd91a
      result = vld2_dup_u32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_u32(result.val[0]), 0);
         exp = UINT64_C(0x7fffd91a7fffd91a);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_u32(result.val[1]), 0);
         exp = UINT64_C(0x8000800080008000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1409() {

{
   {
      uint64_t arg1[2];
      uint64x1x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"load2_alllanes\", fnname = \"vld2_dup_u64\", rettype = \"uint64x1x2_t\", argtypes = \"[__transfersize(2) uint64_t const *]\", vals = [PtrVal [IntegerVal 3952612362606837760,IntegerVal 9223512776490647551]], start_saturated = False}";
      int reported = 0;
      arg1[0] = UINT64_C(0x36da80007fff8000);
      arg1[1] = UINT64_C(0x8000800080007fff);
      clear_neon_saturated();
      //  Expect: "result" = 8000800080007fff36da80007fff8000
      result = vld2_dup_u64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(result.val[0], 0);
         exp = UINT64_C(0x36da80007fff8000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(result.val[1], 0);
         exp = UINT64_C(0x8000800080007fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1410() {

{
   {
      int8_t arg1[2];
      int8x8x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"load2_alllanes\", fnname = \"vld2_dup_s8\", rettype = \"int8x8x2_t\", argtypes = \"[__transfersize(2) int8_t const *]\", vals = [PtrVal [IntegerVal 0,IntegerVal (-128)]], start_saturated = False}";
      int reported = 0;
      arg1[0] = 0;
      arg1[1] = -128;
      clear_neon_saturated();
      //  Expect: "result" = 80808080808080800000000000000000
      result = vld2_dup_s8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_s8(result.val[0]), 0);
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_s8(result.val[1]), 0);
         exp = UINT64_C(0x8080808080808080);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1411() {

{
   {
      int16_t arg1[2];
      int16x4x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"load2_alllanes\", fnname = \"vld2_dup_s16\", rettype = \"int16x4x2_t\", argtypes = \"[__transfersize(2) int16_t const *]\", vals = [PtrVal [IntegerVal 32767,IntegerVal 32767]], start_saturated = False}";
      int reported = 0;
      arg1[0] = 32767;
      arg1[1] = 32767;
      clear_neon_saturated();
      //  Expect: "result" = 7fff7fff7fff7fff7fff7fff7fff7fff
      result = vld2_dup_s16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_s16(result.val[0]), 0);
         exp = UINT64_C(0x7fff7fff7fff7fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_s16(result.val[1]), 0);
         exp = UINT64_C(0x7fff7fff7fff7fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1412() {

{
   {
      int32_t arg1[2];
      int32x2x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"load2_alllanes\", fnname = \"vld2_dup_s32\", rettype = \"int32x2x2_t\", argtypes = \"[__transfersize(2) int32_t const *]\", vals = [PtrVal [IntegerVal 65535,IntegerVal (-31592)]], start_saturated = False}";
      int reported = 0;
      arg1[0] = 65535;
      arg1[1] = -31592;
      clear_neon_saturated();
      //  Expect: "result" = ffff8498ffff84980000ffff0000ffff
      result = vld2_dup_s32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_s32(result.val[0]), 0);
         exp = UINT64_C(0x0000ffff0000ffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_s32(result.val[1]), 0);
         exp = UINT64_C(0xffff8498ffff8498);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1413() {

{
   {
      int64_t arg1[2];
      int64x1x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"load2_alllanes\", fnname = \"vld2_dup_s64\", rettype = \"int64x1x2_t\", argtypes = \"[__transfersize(2) int64_t const *]\", vals = [PtrVal [IntegerVal (-281473682767872),IntegerVal 9223231297218904064]], start_saturated = False}";
      int reported = 0;
      arg1[0] = INT64_C(-281473682767872);
      arg1[1] = INT64_C(9223231297218904064);
      clear_neon_saturated();
      //  Expect: "result" = 7fff7fff7fff8000ffff00004d200000
      result = vld2_dup_s64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_s64(result.val[0]), 0);
         exp = UINT64_C(0xffff00004d200000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_s64(result.val[1]), 0);
         exp = UINT64_C(0x7fff7fff7fff8000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1414() {

{
   {
      float32_t arg1[2];
      float32x2x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"load2_alllanes\", fnname = \"vld2_dup_f32\", rettype = \"float32x2x2_t\", argtypes = \"[__transfersize(2) float32_t const *]\", vals = [PtrVal [FloatVal 0.7116019129753113,FloatVal 0.14166736602783203]], start_saturated = False}";
      int reported = 0;
      arg1[0] = ((float32_t) 0.7116019129753113);
      arg1[1] = ((float32_t) 0.14166736602783203);
      clear_neon_saturated();
      //  Expect: "result" = 3e1111403e1111403f362b8b3f362b8b
      result = vld2_dup_f32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result.val[0], 0);
         exp = ((float32_t) 0.7116019129753113);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 0 ",
                      exp,
                      got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result.val[0], 1);
         exp = ((float32_t) 0.7116019129753113);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 1 ",
                      exp,
                      got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result.val[1], 0);
         exp = ((float32_t) 0.14166736602783203);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 0 ",
                      exp,
                      got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result.val[1], 1);
         exp = ((float32_t) 0.14166736602783203);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 1 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1415() {

{
   {
      float64_t arg1[2];
      float64x1x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"load2_alllanes\", fnname = \"vld2_dup_f64\", rettype = \"float64x1x2_t\", argtypes = \"[__transfersize(2) float64_t const *]\", vals = [PtrVal [FloatVal 0.6409929641446055,FloatVal 0.2704573006417822]], start_saturated = False}";
      int reported = 0;
      arg1[0] = 0.6409929641446055;
      arg1[1] = 0.2704573006417822;
      clear_neon_saturated();
      //  Expect: "result" = 3fd14f2c234e23223fe48303ad3ef326
      result = vld2_dup_f64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float64_t got;
         float64_t exp;
         got = vget_lane_f64(result.val[0], 0);
         exp = 0.6409929641446055;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 0 ",
                      exp,
                      got);
            }
      }
      {
         float64_t got;
         float64_t exp;
         got = vget_lane_f64(result.val[1], 0);
         exp = 0.2704573006417822;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 0 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1416() {

{
   {
      poly8_t arg1[2];
      poly8x8x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"load2_alllanes\", fnname = \"vld2_dup_p8\", rettype = \"poly8x8x2_t\", argtypes = \"[__transfersize(2) poly8_t const *]\", vals = [PtrVal [PolyVal [1,0,1,0,1,0,1,0],PolyVal [0,1,0,0,0,0,0,0]]], start_saturated = False}";
      int reported = 0;
      arg1[0] = 85;
      arg1[1] = 2;
      clear_neon_saturated();
      //  Expect: "result" = 02020202020202025555555555555555
      result = vld2_dup_p8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_p8(result.val[0]), 0);
         exp = UINT64_C(0x5555555555555555);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_p8(result.val[1]), 0);
         exp = UINT64_C(0x0202020202020202);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1417() {

{
   {
      poly16_t arg1[2];
      poly16x4x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"load2_alllanes\", fnname = \"vld2_dup_p16\", rettype = \"poly16x4x2_t\", argtypes = \"[__transfersize(2) poly16_t const *]\", vals = [PtrVal [PolyVal [1,1,0,0,1,0,1,1,1,1,1,0,1,1,0,0],PolyVal [1,0,0,1,1,0,0,1,0,1,1,1,1,0,0,0]]], start_saturated = False}";
      int reported = 0;
      arg1[0] = 14291;
      arg1[1] = 7833;
      clear_neon_saturated();
      //  Expect: "result" = 1e991e991e991e9937d337d337d337d3
      result = vld2_dup_p16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_p16(result.val[0]), 0);
         exp = UINT64_C(0x37d337d337d337d3);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_p16(result.val[1]), 0);
         exp = UINT64_C(0x1e991e991e991e99);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1418() {
#if __ARM_NEON_FP16_INTRINSICS

{
   {
      __fp16 arg1[2];
      float16x4x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"load2_alllanes\", fnname = \"vld2_dup_f16\", rettype = \"float16x4x2_t\", argtypes = \"[__transfersize(2) __fp16 const *]\", vals = [PtrVal [FloatVal (-6.262682298452327),FloatVal 5.7770805942266374]], start_saturated = False}";
      int reported = 0;
      arg1[0] = -6.262682298452327;
      arg1[1] = 5.7770805942266374;
      clear_neon_saturated();
      //  Expect: "result" = 45c645c645c645c6c643c643c643c643
      result = vld2_dup_f16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         __fp16 got;
         __fp16 exp;
         got = vget_lane_f16(result.val[0], 0);
         exp = -6.262682298452327;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 0 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vget_lane_f16(result.val[0], 1);
         exp = -6.262682298452327;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 1 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vget_lane_f16(result.val[0], 2);
         exp = -6.262682298452327;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 2 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vget_lane_f16(result.val[0], 3);
         exp = -6.262682298452327;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 3 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vget_lane_f16(result.val[1], 0);
         exp = 5.7770805942266374;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 0 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vget_lane_f16(result.val[1], 1);
         exp = 5.7770805942266374;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 1 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vget_lane_f16(result.val[1], 2);
         exp = 5.7770805942266374;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 2 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vget_lane_f16(result.val[1], 3);
         exp = 5.7770805942266374;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 3 ",
                      exp,
                      got);
            }
      }
   }
}
#endif
}
void dotests_1419() {

{
   {
      poly64_t arg1[2];
      poly64x1x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"load2_alllanes\", fnname = \"vld2_dup_p64\", rettype = \"poly64x1x2_t\", argtypes = \"[__transfersize(2) poly64_t const *]\", vals = [PtrVal [PolyVal [1,0,0,0,1,1,1,1,0,1,0,0,0,0,0,1,0,1,0,0,0,1,0,1,0,0,1,0,0,1,1,1,0,0,0,1,1,0,0,0,0,1,0,1,1,0,0,1,0,1,1,0,1,1,1,0,1,0,1,1,1,1,0,0],PolyVal [1,1,1,1,1,1,1,1,0,0,1,0,1,0,1,1,0,0,0,0,0,1,0,1,1,0,0,0,1,1,0,0,0,0,0,0,0,1,0,0,1,1,0,1,0,0,0,1,0,1,1,1,0,1,0,1,0,1,1,0,0,0,0,1]]], start_saturated = False}";
      int reported = 0;
      arg1[0] = 4428896715271209713;
      arg1[1] = -8741896856291715841;
      clear_neon_saturated();
      //  Expect: "result" = 86ae8b2031a0d4ff3d769a18e4a282f1
      result = vld2_dup_p64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_p64(result.val[0]), 0);
         exp = UINT64_C(0x3d769a18e4a282f1);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_p64(result.val[1]), 0);
         exp = UINT64_C(0x86ae8b2031a0d4ff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1420() {

{
   {
      uint8_t arg1[2];
      uint8x16x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"load2_alllanes\", fnname = \"vld2q_dup_u8\", rettype = \"uint8x16x2_t\", argtypes = \"[__transfersize(2) uint8_t const *]\", vals = [PtrVal [IntegerVal 74,IntegerVal 255]], start_saturated = False}";
      int reported = 0;
      arg1[0] = 74U;
      arg1[1] = 255U;
      clear_neon_saturated();
      //  Expect: "result" = ffffffffffffffffffffffffffffffff4a4a4a4a4a4a4a4a4a4a4a4a4a4a4a4a
      result = vld2q_dup_u8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result.val[0]), 0);
         exp = UINT64_C(0x4a4a4a4a4a4a4a4a);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result.val[0]), 1);
         exp = UINT64_C(0x4a4a4a4a4a4a4a4a);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result.val[1]), 0);
         exp = UINT64_C(0xffffffffffffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result.val[1]), 1);
         exp = UINT64_C(0xffffffffffffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1421() {

{
   {
      uint16_t arg1[2];
      uint16x8x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"load2_alllanes\", fnname = \"vld2q_dup_u16\", rettype = \"uint16x8x2_t\", argtypes = \"[__transfersize(2) uint16_t const *]\", vals = [PtrVal [IntegerVal 32768,IntegerVal 0]], start_saturated = False}";
      int reported = 0;
      arg1[0] = 32768U;
      arg1[1] = 0;
      clear_neon_saturated();
      //  Expect: "result" = 0000000000000000000000000000000080008000800080008000800080008000
      result = vld2q_dup_u16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result.val[0]), 0);
         exp = UINT64_C(0x8000800080008000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result.val[0]), 1);
         exp = UINT64_C(0x8000800080008000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result.val[1]), 0);
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result.val[1]), 1);
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1422() {

{
   {
      uint32_t arg1[2];
      uint32x4x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"load2_alllanes\", fnname = \"vld2q_dup_u32\", rettype = \"uint32x4x2_t\", argtypes = \"[__transfersize(2) uint32_t const *]\", vals = [PtrVal [IntegerVal 2147503485,IntegerVal 2147453434]], start_saturated = False}";
      int reported = 0;
      arg1[0] = 2147503485U;
      arg1[1] = 2147453434U;
      clear_neon_saturated();
      //  Expect: "result" = 7fff89fa7fff89fa7fff89fa7fff89fa80004d7d80004d7d80004d7d80004d7d
      result = vld2q_dup_u32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result.val[0]), 0);
         exp = UINT64_C(0x80004d7d80004d7d);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result.val[0]), 1);
         exp = UINT64_C(0x80004d7d80004d7d);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result.val[1]), 0);
         exp = UINT64_C(0x7fff89fa7fff89fa);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result.val[1]), 1);
         exp = UINT64_C(0x7fff89fa7fff89fa);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1423() {

{
   {
      uint64_t arg1[2];
      uint64x2x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"load2_alllanes\", fnname = \"vld2q_dup_u64\", rettype = \"uint64x2x2_t\", argtypes = \"[__transfersize(2) uint64_t const *]\", vals = [PtrVal [IntegerVal 140735340838912,IntegerVal 1539386645024899071]], start_saturated = False}";
      int reported = 0;
      arg1[0] = UINT64_C(0x00007fff7fff8000);
      arg1[1] = UINT64_C(0x155cffff64b07fff);
      clear_neon_saturated();
      //  Expect: "result" = 155cffff64b07fff155cffff64b07fff00007fff7fff800000007fff7fff8000
      result = vld2q_dup_u64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result.val[0], 0);
         exp = UINT64_C(0x00007fff7fff8000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result.val[0], 1);
         exp = UINT64_C(0x00007fff7fff8000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result.val[1], 0);
         exp = UINT64_C(0x155cffff64b07fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result.val[1], 1);
         exp = UINT64_C(0x155cffff64b07fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1424() {

{
   {
      int8_t arg1[2];
      int8x16x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"load2_alllanes\", fnname = \"vld2q_dup_s8\", rettype = \"int8x16x2_t\", argtypes = \"[__transfersize(2) int8_t const *]\", vals = [PtrVal [IntegerVal (-128),IntegerVal (-18)]], start_saturated = False}";
      int reported = 0;
      arg1[0] = -128;
      arg1[1] = -18;
      clear_neon_saturated();
      //  Expect: "result" = eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee80808080808080808080808080808080
      result = vld2q_dup_s8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result.val[0]), 0);
         exp = UINT64_C(0x8080808080808080);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result.val[0]), 1);
         exp = UINT64_C(0x8080808080808080);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result.val[1]), 0);
         exp = UINT64_C(0xeeeeeeeeeeeeeeee);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result.val[1]), 1);
         exp = UINT64_C(0xeeeeeeeeeeeeeeee);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1425() {

{
   {
      int16_t arg1[2];
      int16x8x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"load2_alllanes\", fnname = \"vld2q_dup_s16\", rettype = \"int16x8x2_t\", argtypes = \"[__transfersize(2) int16_t const *]\", vals = [PtrVal [IntegerVal (-32768),IntegerVal (-10394)]], start_saturated = False}";
      int reported = 0;
      arg1[0] = -32768;
      arg1[1] = -10394;
      clear_neon_saturated();
      //  Expect: "result" = d766d766d766d766d766d766d766d76680008000800080008000800080008000
      result = vld2q_dup_s16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result.val[0]), 0);
         exp = UINT64_C(0x8000800080008000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result.val[0]), 1);
         exp = UINT64_C(0x8000800080008000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result.val[1]), 0);
         exp = UINT64_C(0xd766d766d766d766);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result.val[1]), 1);
         exp = UINT64_C(0xd766d766d766d766);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1426() {

{
   {
      int32_t arg1[2];
      int32x4x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"load2_alllanes\", fnname = \"vld2q_dup_s32\", rettype = \"int32x4x2_t\", argtypes = \"[__transfersize(2) int32_t const *]\", vals = [PtrVal [IntegerVal (-2147450880),IntegerVal (-32769)]], start_saturated = False}";
      int reported = 0;
      arg1[0] = -2147450880;
      arg1[1] = -32769;
      clear_neon_saturated();
      //  Expect: "result" = ffff7fffffff7fffffff7fffffff7fff80008000800080008000800080008000
      result = vld2q_dup_s32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result.val[0]), 0);
         exp = UINT64_C(0x8000800080008000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result.val[0]), 1);
         exp = UINT64_C(0x8000800080008000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result.val[1]), 0);
         exp = UINT64_C(0xffff7fffffff7fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result.val[1]), 1);
         exp = UINT64_C(0xffff7fffffff7fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1427() {

{
   {
      int64_t arg1[2];
      int64x2x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"load2_alllanes\", fnname = \"vld2q_dup_s64\", rettype = \"int64x2x2_t\", argtypes = \"[__transfersize(2) int64_t const *]\", vals = [PtrVal [IntegerVal 177272627704225,IntegerVal (-9223231297218969601)]], start_saturated = False}";
      int reported = 0;
      arg1[0] = INT64_C(177272627704225);
      arg1[1] = INT64_C(-9223231297218969601);
      clear_neon_saturated();
      //  Expect: "result" = 800080007fff7fff800080007fff7fff0000a13a8000b1a10000a13a8000b1a1
      result = vld2q_dup_s64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result.val[0]), 0);
         exp = UINT64_C(0x0000a13a8000b1a1);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result.val[0]), 1);
         exp = UINT64_C(0x0000a13a8000b1a1);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result.val[1]), 0);
         exp = UINT64_C(0x800080007fff7fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result.val[1]), 1);
         exp = UINT64_C(0x800080007fff7fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1428() {

{
   {
      float32_t arg1[2];
      float32x4x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"load2_alllanes\", fnname = \"vld2q_dup_f32\", rettype = \"float32x4x2_t\", argtypes = \"[__transfersize(2) float32_t const *]\", vals = [PtrVal [FloatVal 0.9774073958396912,FloatVal 0.9505500197410583]], start_saturated = False}";
      int reported = 0;
      arg1[0] = ((float32_t) 0.9774073958396912);
      arg1[1] = ((float32_t) 0.9505500197410583);
      clear_neon_saturated();
      //  Expect: "result" = 3f73573f3f73573f3f73573f3f73573f3f7a375f3f7a375f3f7a375f3f7a375f
      result = vld2q_dup_f32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result.val[0], 0);
         exp = ((float32_t) 0.9774073958396912);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 0 ",
                      exp,
                      got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result.val[0], 1);
         exp = ((float32_t) 0.9774073958396912);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 1 ",
                      exp,
                      got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result.val[0], 2);
         exp = ((float32_t) 0.9774073958396912);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 2 ",
                      exp,
                      got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result.val[0], 3);
         exp = ((float32_t) 0.9774073958396912);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 3 ",
                      exp,
                      got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result.val[1], 0);
         exp = ((float32_t) 0.9505500197410583);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 0 ",
                      exp,
                      got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result.val[1], 1);
         exp = ((float32_t) 0.9505500197410583);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 1 ",
                      exp,
                      got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result.val[1], 2);
         exp = ((float32_t) 0.9505500197410583);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 2 ",
                      exp,
                      got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result.val[1], 3);
         exp = ((float32_t) 0.9505500197410583);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 3 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1429() {

{
   {
      float64_t arg1[2];
      float64x2x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"load2_alllanes\", fnname = \"vld2q_dup_f64\", rettype = \"float64x2x2_t\", argtypes = \"[__transfersize(2) float64_t const *]\", vals = [PtrVal [FloatVal 0.8929550676359934,FloatVal 0.15473572939708213]], start_saturated = False}";
      int reported = 0;
      arg1[0] = 0.8929550676359934;
      arg1[1] = 0.15473572939708213;
      clear_neon_saturated();
      //  Expect: "result" = 3fc3ce6160a43f083fc3ce6160a43f083fec9316818968f03fec9316818968f0
      result = vld2q_dup_f64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float64_t got;
         float64_t exp;
         got = vgetq_lane_f64(result.val[0], 0);
         exp = 0.8929550676359934;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 0 ",
                      exp,
                      got);
            }
      }
      {
         float64_t got;
         float64_t exp;
         got = vgetq_lane_f64(result.val[0], 1);
         exp = 0.8929550676359934;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 1 ",
                      exp,
                      got);
            }
      }
      {
         float64_t got;
         float64_t exp;
         got = vgetq_lane_f64(result.val[1], 0);
         exp = 0.15473572939708213;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 0 ",
                      exp,
                      got);
            }
      }
      {
         float64_t got;
         float64_t exp;
         got = vgetq_lane_f64(result.val[1], 1);
         exp = 0.15473572939708213;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 1 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1430() {

{
   {
      poly8_t arg1[2];
      poly8x16x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"load2_alllanes\", fnname = \"vld2q_dup_p8\", rettype = \"poly8x16x2_t\", argtypes = \"[__transfersize(2) poly8_t const *]\", vals = [PtrVal [PolyVal [1,0,1,0,0,0,1,1],PolyVal [1,1,1,0,1,0,0,1]]], start_saturated = False}";
      int reported = 0;
      arg1[0] = 197;
      arg1[1] = 151;
      clear_neon_saturated();
      //  Expect: "result" = 97979797979797979797979797979797c5c5c5c5c5c5c5c5c5c5c5c5c5c5c5c5
      result = vld2q_dup_p8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p8(result.val[0]), 0);
         exp = UINT64_C(0xc5c5c5c5c5c5c5c5);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p8(result.val[0]), 1);
         exp = UINT64_C(0xc5c5c5c5c5c5c5c5);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p8(result.val[1]), 0);
         exp = UINT64_C(0x9797979797979797);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p8(result.val[1]), 1);
         exp = UINT64_C(0x9797979797979797);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1431() {

{
   {
      poly16_t arg1[2];
      poly16x8x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"load2_alllanes\", fnname = \"vld2q_dup_p16\", rettype = \"poly16x8x2_t\", argtypes = \"[__transfersize(2) poly16_t const *]\", vals = [PtrVal [PolyVal [0,1,0,0,0,1,1,1,0,0,0,1,1,0,1,0],PolyVal [1,0,0,0,1,0,1,1,1,1,1,1,1,1,0,1]]], start_saturated = False}";
      int reported = 0;
      arg1[0] = 22754;
      arg1[1] = 49105;
      clear_neon_saturated();
      //  Expect: "result" = bfd1bfd1bfd1bfd1bfd1bfd1bfd1bfd158e258e258e258e258e258e258e258e2
      result = vld2q_dup_p16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p16(result.val[0]), 0);
         exp = UINT64_C(0x58e258e258e258e2);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p16(result.val[0]), 1);
         exp = UINT64_C(0x58e258e258e258e2);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p16(result.val[1]), 0);
         exp = UINT64_C(0xbfd1bfd1bfd1bfd1);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p16(result.val[1]), 1);
         exp = UINT64_C(0xbfd1bfd1bfd1bfd1);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1432() {
#if __ARM_NEON_FP16_INTRINSICS

{
   {
      __fp16 arg1[2];
      float16x8x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"load2_alllanes\", fnname = \"vld2q_dup_f16\", rettype = \"float16x8x2_t\", argtypes = \"[__transfersize(2) __fp16 const *]\", vals = [PtrVal [FloatVal 7.977609604640058,FloatVal 3.0608640327300467]], start_saturated = False}";
      int reported = 0;
      arg1[0] = 7.977609604640058;
      arg1[1] = 3.0608640327300467;
      clear_neon_saturated();
      //  Expect: "result" = 421f421f421f421f421f421f421f421f47fa47fa47fa47fa47fa47fa47fa47fa
      result = vld2q_dup_f16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[0], 0);
         exp = 7.977609604640058;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 0 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[0], 1);
         exp = 7.977609604640058;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 1 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[0], 2);
         exp = 7.977609604640058;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 2 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[0], 3);
         exp = 7.977609604640058;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 3 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[0], 4);
         exp = 7.977609604640058;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 4 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[0], 5);
         exp = 7.977609604640058;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 5 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[0], 6);
         exp = 7.977609604640058;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 6 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[0], 7);
         exp = 7.977609604640058;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 7 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[1], 0);
         exp = 3.0608640327300467;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 0 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[1], 1);
         exp = 3.0608640327300467;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 1 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[1], 2);
         exp = 3.0608640327300467;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 2 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[1], 3);
         exp = 3.0608640327300467;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 3 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[1], 4);
         exp = 3.0608640327300467;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 4 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[1], 5);
         exp = 3.0608640327300467;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 5 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[1], 6);
         exp = 3.0608640327300467;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 6 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[1], 7);
         exp = 3.0608640327300467;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 7 ",
                      exp,
                      got);
            }
      }
   }
}
#endif
}
void dotests_1433() {

{
   {
      poly64_t arg1[2];
      poly64x2x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"load2_alllanes\", fnname = \"vld2q_dup_p64\", rettype = \"poly64x2x2_t\", argtypes = \"[__transfersize(2) poly64_t const *]\", vals = [PtrVal [PolyVal [1,0,0,0,0,0,0,0,1,1,1,1,0,1,1,0,1,0,1,0,0,0,0,0,1,1,1,0,0,1,1,0,1,1,1,0,0,1,1,0,1,0,1,0,1,0,0,1,1,0,0,1,1,1,0,1,1,1,1,0,1,1,1,0],PolyVal [0,0,1,1,0,0,1,0,1,1,0,0,1,0,0,0,0,1,1,0,0,0,1,0,0,0,1,0,0,1,0,1,1,0,1,1,0,1,0,1,1,0,0,0,1,1,0,0,1,0,1,0,1,0,0,0,0,1,1,1,0,1,1,0]]], start_saturated = False}";
      int reported = 0;
      arg1[0] = 8627090832547475201;
      arg1[1] = 7932300940538155852;
      clear_neon_saturated();
      //  Expect: "result" = 6e1531ada446134c6e1531ada446134c77b9956767056f0177b9956767056f01
      result = vld2q_dup_p64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p64(result.val[0]), 0);
         exp = UINT64_C(0x77b9956767056f01);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p64(result.val[0]), 1);
         exp = UINT64_C(0x77b9956767056f01);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p64(result.val[1]), 0);
         exp = UINT64_C(0x6e1531ada446134c);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p64(result.val[1]), 1);
         exp = UINT64_C(0x6e1531ada446134c);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1434() {

{
   {
      uint8_t arg1[3];
      uint8x8x3_t result;
      char* str1 = "ReproInfo2 {semantics = \"load3_alllanes\", fnname = \"vld3_dup_u8\", rettype = \"uint8x8x3_t\", argtypes = \"[__transfersize(3) uint8_t const *]\", vals = [PtrVal [IntegerVal 253,IntegerVal 0,IntegerVal 74]], start_saturated = False}";
      int reported = 0;
      arg1[0] = 253U;
      arg1[1] = 0;
      arg1[2] = 74U;
      clear_neon_saturated();
      //  Expect: "result" = 4a4a4a4a4a4a4a4a0000000000000000fdfdfdfdfdfdfdfd
      result = vld3_dup_u8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_u8(result.val[0]), 0);
         exp = UINT64_C(0xfdfdfdfdfdfdfdfd);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_u8(result.val[1]), 0);
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_u8(result.val[2]), 0);
         exp = UINT64_C(0x4a4a4a4a4a4a4a4a);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1435() {

{
   {
      uint16_t arg1[3];
      uint16x4x3_t result;
      char* str1 = "ReproInfo2 {semantics = \"load3_alllanes\", fnname = \"vld3_dup_u16\", rettype = \"uint16x4x3_t\", argtypes = \"[__transfersize(3) uint16_t const *]\", vals = [PtrVal [IntegerVal 65535,IntegerVal 45556,IntegerVal 65535]], start_saturated = False}";
      int reported = 0;
      arg1[0] = 65535U;
      arg1[1] = 45556U;
      arg1[2] = 65535U;
      clear_neon_saturated();
      //  Expect: "result" = ffffffffffffffffb1f4b1f4b1f4b1f4ffffffffffffffff
      result = vld3_dup_u16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_u16(result.val[0]), 0);
         exp = UINT64_C(0xffffffffffffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_u16(result.val[1]), 0);
         exp = UINT64_C(0xb1f4b1f4b1f4b1f4);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_u16(result.val[2]), 0);
         exp = UINT64_C(0xffffffffffffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1436() {

{
   {
      uint32_t arg1[3];
      uint32x2x3_t result;
      char* str1 = "ReproInfo2 {semantics = \"load3_alllanes\", fnname = \"vld3_dup_u32\", rettype = \"uint32x2x3_t\", argtypes = \"[__transfersize(3) uint32_t const *]\", vals = [PtrVal [IntegerVal 4294967295,IntegerVal 0,IntegerVal 4294967295]], start_saturated = False}";
      int reported = 0;
      arg1[0] = 4294967295U;
      arg1[1] = 0;
      arg1[2] = 4294967295U;
      clear_neon_saturated();
      //  Expect: "result" = ffffffffffffffff0000000000000000ffffffffffffffff
      result = vld3_dup_u32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_u32(result.val[0]), 0);
         exp = UINT64_C(0xffffffffffffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_u32(result.val[1]), 0);
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_u32(result.val[2]), 0);
         exp = UINT64_C(0xffffffffffffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1437() {

{
   {
      uint64_t arg1[3];
      uint64x1x3_t result;
      char* str1 = "ReproInfo2 {semantics = \"load3_alllanes\", fnname = \"vld3_dup_u64\", rettype = \"uint64x1x3_t\", argtypes = \"[__transfersize(3) uint64_t const *]\", vals = [PtrVal [IntegerVal 9223372032559828477,IntegerVal 18446462599588282367,IntegerVal 9223653509684035583]], start_saturated = False}";
      int reported = 0;
      arg1[0] = UINT64_C(0x7fffffff00004dfd);
      arg1[1] = UINT64_C(0xffff000032fcffff);
      arg1[2] = UINT64_C(0x8000ffff80007fff);
      clear_neon_saturated();
      //  Expect: "result" = 8000ffff80007fffffff000032fcffff7fffffff00004dfd
      result = vld3_dup_u64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(result.val[0], 0);
         exp = UINT64_C(0x7fffffff00004dfd);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(result.val[1], 0);
         exp = UINT64_C(0xffff000032fcffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(result.val[2], 0);
         exp = UINT64_C(0x8000ffff80007fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1438() {

{
   {
      int8_t arg1[3];
      int8x8x3_t result;
      char* str1 = "ReproInfo2 {semantics = \"load3_alllanes\", fnname = \"vld3_dup_s8\", rettype = \"int8x8x3_t\", argtypes = \"[__transfersize(3) int8_t const *]\", vals = [PtrVal [IntegerVal (-1),IntegerVal 127,IntegerVal (-1)]], start_saturated = False}";
      int reported = 0;
      arg1[0] = -1;
      arg1[1] = 127;
      arg1[2] = -1;
      clear_neon_saturated();
      //  Expect: "result" = ffffffffffffffff7f7f7f7f7f7f7f7fffffffffffffffff
      result = vld3_dup_s8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_s8(result.val[0]), 0);
         exp = UINT64_C(0xffffffffffffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_s8(result.val[1]), 0);
         exp = UINT64_C(0x7f7f7f7f7f7f7f7f);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_s8(result.val[2]), 0);
         exp = UINT64_C(0xffffffffffffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1439() {

{
   {
      int16_t arg1[3];
      int16x4x3_t result;
      char* str1 = "ReproInfo2 {semantics = \"load3_alllanes\", fnname = \"vld3_dup_s16\", rettype = \"int16x4x3_t\", argtypes = \"[__transfersize(3) int16_t const *]\", vals = [PtrVal [IntegerVal 0,IntegerVal (-10420),IntegerVal (-32768)]], start_saturated = False}";
      int reported = 0;
      arg1[0] = 0;
      arg1[1] = -10420;
      arg1[2] = -32768;
      clear_neon_saturated();
      //  Expect: "result" = 8000800080008000d74cd74cd74cd74c0000000000000000
      result = vld3_dup_s16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_s16(result.val[0]), 0);
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_s16(result.val[1]), 0);
         exp = UINT64_C(0xd74cd74cd74cd74c);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_s16(result.val[2]), 0);
         exp = UINT64_C(0x8000800080008000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1440() {

{
   {
      int32_t arg1[3];
      int32x2x3_t result;
      char* str1 = "ReproInfo2 {semantics = \"load3_alllanes\", fnname = \"vld3_dup_s32\", rettype = \"int32x2x3_t\", argtypes = \"[__transfersize(3) int32_t const *]\", vals = [PtrVal [IntegerVal (-2147450881),IntegerVal 2147418112,IntegerVal (-65536)]], start_saturated = False}";
      int reported = 0;
      arg1[0] = -2147450881;
      arg1[1] = 2147418112;
      arg1[2] = -65536;
      clear_neon_saturated();
      //  Expect: "result" = ffff0000ffff00007fff00007fff000080007fff80007fff
      result = vld3_dup_s32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_s32(result.val[0]), 0);
         exp = UINT64_C(0x80007fff80007fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_s32(result.val[1]), 0);
         exp = UINT64_C(0x7fff00007fff0000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_s32(result.val[2]), 0);
         exp = UINT64_C(0xffff0000ffff0000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1441() {

{
   {
      int64_t arg1[3];
      int64x1x3_t result;
      char* str1 = "ReproInfo2 {semantics = \"load3_alllanes\", fnname = \"vld3_dup_s64\", rettype = \"int64x1x3_t\", argtypes = \"[__transfersize(3) int64_t const *]\", vals = [PtrVal [IntegerVal 140733193453567,IntegerVal (-32768),IntegerVal 8833106979498018046]], start_saturated = False}";
      int reported = 0;
      arg1[0] = INT64_C(140733193453567);
      arg1[1] = INT64_C(-32768);
      arg1[2] = INT64_C(8833106979498018046);
      clear_neon_saturated();
      //  Expect: "result" = 7a957fff8000c4feffffffffffff800000007fff0000ffff
      result = vld3_dup_s64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_s64(result.val[0]), 0);
         exp = UINT64_C(0x00007fff0000ffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_s64(result.val[1]), 0);
         exp = UINT64_C(0xffffffffffff8000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_s64(result.val[2]), 0);
         exp = UINT64_C(0x7a957fff8000c4fe);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1442() {

{
   {
      float32_t arg1[3];
      float32x2x3_t result;
      char* str1 = "ReproInfo2 {semantics = \"load3_alllanes\", fnname = \"vld3_dup_f32\", rettype = \"float32x2x3_t\", argtypes = \"[__transfersize(3) float32_t const *]\", vals = [PtrVal [FloatVal 0.6166287660598755,FloatVal 0.7483401298522949,FloatVal 0.5464107394218445]], start_saturated = False}";
      int reported = 0;
      arg1[0] = ((float32_t) 0.6166287660598755);
      arg1[1] = ((float32_t) 0.7483401298522949);
      arg1[2] = ((float32_t) 0.5464107394218445);
      clear_neon_saturated();
      //  Expect: "result" = 3f0be1933f0be1933f3f93383f3f93383f1ddb623f1ddb62
      result = vld3_dup_f32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result.val[0], 0);
         exp = ((float32_t) 0.6166287660598755);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 0 ",
                      exp,
                      got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result.val[0], 1);
         exp = ((float32_t) 0.6166287660598755);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 1 ",
                      exp,
                      got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result.val[1], 0);
         exp = ((float32_t) 0.7483401298522949);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 0 ",
                      exp,
                      got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result.val[1], 1);
         exp = ((float32_t) 0.7483401298522949);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 1 ",
                      exp,
                      got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result.val[2], 0);
         exp = ((float32_t) 0.5464107394218445);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 2 Lane 0 ",
                      exp,
                      got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result.val[2], 1);
         exp = ((float32_t) 0.5464107394218445);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 2 Lane 1 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1443() {

{
   {
      float64_t arg1[3];
      float64x1x3_t result;
      char* str1 = "ReproInfo2 {semantics = \"load3_alllanes\", fnname = \"vld3_dup_f64\", rettype = \"float64x1x3_t\", argtypes = \"[__transfersize(3) float64_t const *]\", vals = [PtrVal [FloatVal 0.48115641115883767,FloatVal 0.7366990204051398,FloatVal 0.8941336196797232]], start_saturated = False}";
      int reported = 0;
      arg1[0] = 0.48115641115883767;
      arg1[1] = 0.7366990204051398;
      arg1[2] = 0.8941336196797232;
      clear_neon_saturated();
      //  Expect: "result" = 3fec9cbe1bd8e9943fe79309d2f4547a3fdecb44428c072a
      result = vld3_dup_f64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float64_t got;
         float64_t exp;
         got = vget_lane_f64(result.val[0], 0);
         exp = 0.48115641115883767;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 0 ",
                      exp,
                      got);
            }
      }
      {
         float64_t got;
         float64_t exp;
         got = vget_lane_f64(result.val[1], 0);
         exp = 0.7366990204051398;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 0 ",
                      exp,
                      got);
            }
      }
      {
         float64_t got;
         float64_t exp;
         got = vget_lane_f64(result.val[2], 0);
         exp = 0.8941336196797232;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 2 Lane 0 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1444() {

{
   {
      poly8_t arg1[3];
      poly8x8x3_t result;
      char* str1 = "ReproInfo2 {semantics = \"load3_alllanes\", fnname = \"vld3_dup_p8\", rettype = \"poly8x8x3_t\", argtypes = \"[__transfersize(3) poly8_t const *]\", vals = [PtrVal [PolyVal [1,0,1,1,1,1,1,0],PolyVal [0,1,0,1,1,1,1,0],PolyVal [0,0,0,1,1,1,0,0]]], start_saturated = False}";
      int reported = 0;
      arg1[0] = 125;
      arg1[1] = 122;
      arg1[2] = 56;
      clear_neon_saturated();
      //  Expect: "result" = 38383838383838387a7a7a7a7a7a7a7a7d7d7d7d7d7d7d7d
      result = vld3_dup_p8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_p8(result.val[0]), 0);
         exp = UINT64_C(0x7d7d7d7d7d7d7d7d);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_p8(result.val[1]), 0);
         exp = UINT64_C(0x7a7a7a7a7a7a7a7a);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_p8(result.val[2]), 0);
         exp = UINT64_C(0x3838383838383838);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1445() {

{
   {
      poly16_t arg1[3];
      poly16x4x3_t result;
      char* str1 = "ReproInfo2 {semantics = \"load3_alllanes\", fnname = \"vld3_dup_p16\", rettype = \"poly16x4x3_t\", argtypes = \"[__transfersize(3) poly16_t const *]\", vals = [PtrVal [PolyVal [0,1,1,1,0,0,0,1,0,0,1,0,0,1,1,0],PolyVal [1,1,1,0,1,1,0,0,1,1,0,0,0,1,1,1],PolyVal [0,0,0,0,1,1,0,1,1,1,0,1,0,0,1,0]]], start_saturated = False}";
      int reported = 0;
      arg1[0] = 25742;
      arg1[1] = 58167;
      arg1[2] = 19376;
      clear_neon_saturated();
      //  Expect: "result" = 4bb04bb04bb04bb0e337e337e337e337648e648e648e648e
      result = vld3_dup_p16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_p16(result.val[0]), 0);
         exp = UINT64_C(0x648e648e648e648e);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_p16(result.val[1]), 0);
         exp = UINT64_C(0xe337e337e337e337);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_p16(result.val[2]), 0);
         exp = UINT64_C(0x4bb04bb04bb04bb0);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1446() {
#if __ARM_NEON_FP16_INTRINSICS

{
   {
      __fp16 arg1[3];
      float16x4x3_t result;
      char* str1 = "ReproInfo2 {semantics = \"load3_alllanes\", fnname = \"vld3_dup_f16\", rettype = \"float16x4x3_t\", argtypes = \"[__transfersize(3) __fp16 const *]\", vals = [PtrVal [FloatVal 8.650333641433754,FloatVal 3.1519610209226308,FloatVal (-4.398211099193816)]], start_saturated = False}";
      int reported = 0;
      arg1[0] = 8.650333641433754;
      arg1[1] = 3.1519610209226308;
      arg1[2] = -4.398211099193816;
      clear_neon_saturated();
      //  Expect: "result" = c465c465c465c465424d424d424d424d4853485348534853
      result = vld3_dup_f16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         __fp16 got;
         __fp16 exp;
         got = vget_lane_f16(result.val[0], 0);
         exp = 8.650333641433754;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 0 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vget_lane_f16(result.val[0], 1);
         exp = 8.650333641433754;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 1 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vget_lane_f16(result.val[0], 2);
         exp = 8.650333641433754;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 2 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vget_lane_f16(result.val[0], 3);
         exp = 8.650333641433754;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 3 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vget_lane_f16(result.val[1], 0);
         exp = 3.1519610209226308;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 0 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vget_lane_f16(result.val[1], 1);
         exp = 3.1519610209226308;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 1 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vget_lane_f16(result.val[1], 2);
         exp = 3.1519610209226308;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 2 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vget_lane_f16(result.val[1], 3);
         exp = 3.1519610209226308;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 3 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vget_lane_f16(result.val[2], 0);
         exp = -4.398211099193816;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 2 Lane 0 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vget_lane_f16(result.val[2], 1);
         exp = -4.398211099193816;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 2 Lane 1 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vget_lane_f16(result.val[2], 2);
         exp = -4.398211099193816;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 2 Lane 2 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vget_lane_f16(result.val[2], 3);
         exp = -4.398211099193816;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 2 Lane 3 ",
                      exp,
                      got);
            }
      }
   }
}
#endif
}
void dotests_1447() {

{
   {
      poly64_t arg1[3];
      poly64x1x3_t result;
      char* str1 = "ReproInfo2 {semantics = \"load3_alllanes\", fnname = \"vld3_dup_p64\", rettype = \"poly64x1x3_t\", argtypes = \"[__transfersize(3) poly64_t const *]\", vals = [PtrVal [PolyVal [0,1,1,1,0,0,1,0,1,1,1,0,1,0,0,1,0,1,1,1,1,1,1,1,0,1,0,0,1,1,1,1,1,1,1,0,0,0,1,0,0,1,0,1,0,1,0,1,0,1,0,0,0,1,1,1,1,1,1,0,1,1,0,1],PolyVal [1,0,0,1,0,1,0,0,0,0,0,1,1,1,1,0,0,1,0,1,1,1,0,1,0,0,1,1,0,1,0,1,1,1,0,1,1,1,1,0,0,0,0,0,1,1,0,1,0,0,0,1,1,0,1,0,0,0,0,0,0,1,1,0],PolyVal [0,1,0,1,1,0,1,1,1,1,1,1,1,0,1,0,1,0,0,0,1,0,0,0,1,1,0,1,0,1,0,0,1,1,1,0,1,1,1,0,0,0,1,0,0,0,1,1,1,0,0,1,0,1,0,0,1,1,1,0,1,0,0,1]]], start_saturated = False}";
      int reported = 0;
      arg1[0] = -5196403794035959986;
      arg1[1] = 6942492870816987177;
      arg1[2] = -7554290883834585126;
      clear_neon_saturated();
      //  Expect: "result" = 9729c4772b115fda6058b07bacba7829b7e2aa47f2fe974e
      result = vld3_dup_p64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_p64(result.val[0]), 0);
         exp = UINT64_C(0xb7e2aa47f2fe974e);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_p64(result.val[1]), 0);
         exp = UINT64_C(0x6058b07bacba7829);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_p64(result.val[2]), 0);
         exp = UINT64_C(0x9729c4772b115fda);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1448() {

{
   {
      uint8_t arg1[3];
      uint8x16x3_t result;
      char* str1 = "ReproInfo2 {semantics = \"load3_alllanes\", fnname = \"vld3q_dup_u8\", rettype = \"uint8x16x3_t\", argtypes = \"[__transfersize(3) uint8_t const *]\", vals = [PtrVal [IntegerVal 127,IntegerVal 30,IntegerVal 127]], start_saturated = False}";
      int reported = 0;
      arg1[0] = 127U;
      arg1[1] = 30U;
      arg1[2] = 127U;
      clear_neon_saturated();
      //  Expect: "result" = 7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f1e1e1e1e1e1e1e1e1e1e1e1e1e1e1e1e7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f
      result = vld3q_dup_u8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result.val[0]), 0);
         exp = UINT64_C(0x7f7f7f7f7f7f7f7f);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result.val[0]), 1);
         exp = UINT64_C(0x7f7f7f7f7f7f7f7f);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result.val[1]), 0);
         exp = UINT64_C(0x1e1e1e1e1e1e1e1e);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result.val[1]), 1);
         exp = UINT64_C(0x1e1e1e1e1e1e1e1e);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result.val[2]), 0);
         exp = UINT64_C(0x7f7f7f7f7f7f7f7f);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result.val[2]), 1);
         exp = UINT64_C(0x7f7f7f7f7f7f7f7f);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1449() {

{
   {
      uint16_t arg1[3];
      uint16x8x3_t result;
      char* str1 = "ReproInfo2 {semantics = \"load3_alllanes\", fnname = \"vld3q_dup_u16\", rettype = \"uint16x8x3_t\", argtypes = \"[__transfersize(3) uint16_t const *]\", vals = [PtrVal [IntegerVal 32767,IntegerVal 32767,IntegerVal 32767]], start_saturated = False}";
      int reported = 0;
      arg1[0] = 32767U;
      arg1[1] = 32767U;
      arg1[2] = 32767U;
      clear_neon_saturated();
      //  Expect: "result" = 7fff7fff7fff7fff7fff7fff7fff7fff7fff7fff7fff7fff7fff7fff7fff7fff7fff7fff7fff7fff7fff7fff7fff7fff
      result = vld3q_dup_u16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result.val[0]), 0);
         exp = UINT64_C(0x7fff7fff7fff7fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result.val[0]), 1);
         exp = UINT64_C(0x7fff7fff7fff7fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result.val[1]), 0);
         exp = UINT64_C(0x7fff7fff7fff7fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result.val[1]), 1);
         exp = UINT64_C(0x7fff7fff7fff7fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result.val[2]), 0);
         exp = UINT64_C(0x7fff7fff7fff7fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result.val[2]), 1);
         exp = UINT64_C(0x7fff7fff7fff7fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1450() {

{
   {
      uint32_t arg1[3];
      uint32x4x3_t result;
      char* str1 = "ReproInfo2 {semantics = \"load3_alllanes\", fnname = \"vld3q_dup_u32\", rettype = \"uint32x4x3_t\", argtypes = \"[__transfersize(3) uint32_t const *]\", vals = [PtrVal [IntegerVal 26224,IntegerVal 742129663,IntegerVal 4294934527]], start_saturated = False}";
      int reported = 0;
      arg1[0] = 26224U;
      arg1[1] = 742129663U;
      arg1[2] = 4294934527U;
      clear_neon_saturated();
      //  Expect: "result" = ffff7fffffff7fffffff7fffffff7fff2c3bffff2c3bffff2c3bffff2c3bffff00006670000066700000667000006670
      result = vld3q_dup_u32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result.val[0]), 0);
         exp = UINT64_C(0x0000667000006670);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result.val[0]), 1);
         exp = UINT64_C(0x0000667000006670);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result.val[1]), 0);
         exp = UINT64_C(0x2c3bffff2c3bffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result.val[1]), 1);
         exp = UINT64_C(0x2c3bffff2c3bffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result.val[2]), 0);
         exp = UINT64_C(0xffff7fffffff7fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result.val[2]), 1);
         exp = UINT64_C(0xffff7fffffff7fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1451() {

{
   {
      uint64_t arg1[3];
      uint64x2x3_t result;
      char* str1 = "ReproInfo2 {semantics = \"load3_alllanes\", fnname = \"vld3q_dup_u64\", rettype = \"uint64x2x3_t\", argtypes = \"[__transfersize(3) uint64_t const *]\", vals = [PtrVal [IntegerVal 140735340937215,IntegerVal 9223372039002226688,IntegerVal 18446603340072747007]], start_saturated = False}";
      int reported = 0;
      arg1[0] = UINT64_C(0x00007fff8000ffff);
      arg1[1] = UINT64_C(0x800000007fff8000);
      arg1[2] = UINT64_C(0xffff8000e591ffff);
      clear_neon_saturated();
      //  Expect: "result" = ffff8000e591ffffffff8000e591ffff800000007fff8000800000007fff800000007fff8000ffff00007fff8000ffff
      result = vld3q_dup_u64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result.val[0], 0);
         exp = UINT64_C(0x00007fff8000ffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result.val[0], 1);
         exp = UINT64_C(0x00007fff8000ffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result.val[1], 0);
         exp = UINT64_C(0x800000007fff8000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result.val[1], 1);
         exp = UINT64_C(0x800000007fff8000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result.val[2], 0);
         exp = UINT64_C(0xffff8000e591ffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result.val[2], 1);
         exp = UINT64_C(0xffff8000e591ffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1452() {

{
   {
      int8_t arg1[3];
      int8x16x3_t result;
      char* str1 = "ReproInfo2 {semantics = \"load3_alllanes\", fnname = \"vld3q_dup_s8\", rettype = \"int8x16x3_t\", argtypes = \"[__transfersize(3) int8_t const *]\", vals = [PtrVal [IntegerVal (-43),IntegerVal (-128),IntegerVal 127]], start_saturated = False}";
      int reported = 0;
      arg1[0] = -43;
      arg1[1] = -128;
      arg1[2] = 127;
      clear_neon_saturated();
      //  Expect: "result" = 7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f80808080808080808080808080808080d5d5d5d5d5d5d5d5d5d5d5d5d5d5d5d5
      result = vld3q_dup_s8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result.val[0]), 0);
         exp = UINT64_C(0xd5d5d5d5d5d5d5d5);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result.val[0]), 1);
         exp = UINT64_C(0xd5d5d5d5d5d5d5d5);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result.val[1]), 0);
         exp = UINT64_C(0x8080808080808080);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result.val[1]), 1);
         exp = UINT64_C(0x8080808080808080);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result.val[2]), 0);
         exp = UINT64_C(0x7f7f7f7f7f7f7f7f);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result.val[2]), 1);
         exp = UINT64_C(0x7f7f7f7f7f7f7f7f);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1453() {

{
   {
      int16_t arg1[3];
      int16x8x3_t result;
      char* str1 = "ReproInfo2 {semantics = \"load3_alllanes\", fnname = \"vld3q_dup_s16\", rettype = \"int16x8x3_t\", argtypes = \"[__transfersize(3) int16_t const *]\", vals = [PtrVal [IntegerVal 0,IntegerVal 0,IntegerVal (-32768)]], start_saturated = False}";
      int reported = 0;
      arg1[0] = 0;
      arg1[1] = 0;
      arg1[2] = -32768;
      clear_neon_saturated();
      //  Expect: "result" = 800080008000800080008000800080000000000000000000000000000000000000000000000000000000000000000000
      result = vld3q_dup_s16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result.val[0]), 0);
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result.val[0]), 1);
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result.val[1]), 0);
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result.val[1]), 1);
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result.val[2]), 0);
         exp = UINT64_C(0x8000800080008000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result.val[2]), 1);
         exp = UINT64_C(0x8000800080008000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1454() {

{
   {
      int32_t arg1[3];
      int32x4x3_t result;
      char* str1 = "ReproInfo2 {semantics = \"load3_alllanes\", fnname = \"vld3q_dup_s32\", rettype = \"int32x4x3_t\", argtypes = \"[__transfersize(3) int32_t const *]\", vals = [PtrVal [IntegerVal (-1005092865),IntegerVal 32767,IntegerVal 2147483647]], start_saturated = False}";
      int reported = 0;
      arg1[0] = -1005092865;
      arg1[1] = 32767;
      arg1[2] = 2147483647;
      clear_neon_saturated();
      //  Expect: "result" = 7fffffff7fffffff7fffffff7fffffff00007fff00007fff00007fff00007fffc4177fffc4177fffc4177fffc4177fff
      result = vld3q_dup_s32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result.val[0]), 0);
         exp = UINT64_C(0xc4177fffc4177fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result.val[0]), 1);
         exp = UINT64_C(0xc4177fffc4177fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result.val[1]), 0);
         exp = UINT64_C(0x00007fff00007fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result.val[1]), 1);
         exp = UINT64_C(0x00007fff00007fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result.val[2]), 0);
         exp = UINT64_C(0x7fffffff7fffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result.val[2]), 1);
         exp = UINT64_C(0x7fffffff7fffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1455() {

{
   {
      int64_t arg1[3];
      int64x2x3_t result;
      char* str1 = "ReproInfo2 {semantics = \"load3_alllanes\", fnname = \"vld3q_dup_s64\", rettype = \"int64x2x3_t\", argtypes = \"[__transfersize(3) int64_t const *]\", vals = [PtrVal [IntegerVal 42163694010367,IntegerVal 140737488379536,IntegerVal 4294967295]], start_saturated = False}";
      int reported = 0;
      arg1[0] = INT64_C(42163694010367);
      arg1[1] = INT64_C(140737488379536);
      arg1[2] = INT64_C(4294967295);
      clear_neon_saturated();
      //  Expect: "result" = 00000000ffffffff00000000ffffffff0000800000005e900000800000005e90000026590000ffff000026590000ffff
      result = vld3q_dup_s64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result.val[0]), 0);
         exp = UINT64_C(0x000026590000ffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result.val[0]), 1);
         exp = UINT64_C(0x000026590000ffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result.val[1]), 0);
         exp = UINT64_C(0x0000800000005e90);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result.val[1]), 1);
         exp = UINT64_C(0x0000800000005e90);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result.val[2]), 0);
         exp = UINT64_C(0x00000000ffffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result.val[2]), 1);
         exp = UINT64_C(0x00000000ffffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1456() {

{
   {
      float32_t arg1[3];
      float32x4x3_t result;
      char* str1 = "ReproInfo2 {semantics = \"load3_alllanes\", fnname = \"vld3q_dup_f32\", rettype = \"float32x4x3_t\", argtypes = \"[__transfersize(3) float32_t const *]\", vals = [PtrVal [FloatVal 0.5173748731613159,FloatVal 0.6418906450271606,FloatVal 0.7019617557525635]], start_saturated = False}";
      int reported = 0;
      arg1[0] = ((float32_t) 0.5173748731613159);
      arg1[1] = ((float32_t) 0.6418906450271606);
      arg1[2] = ((float32_t) 0.7019617557525635);
      clear_neon_saturated();
      //  Expect: "result" = 3f33b3c43f33b3c43f33b3c43f33b3c43f2452f23f2452f23f2452f23f2452f23f0472ae3f0472ae3f0472ae3f0472ae
      result = vld3q_dup_f32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result.val[0], 0);
         exp = ((float32_t) 0.5173748731613159);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 0 ",
                      exp,
                      got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result.val[0], 1);
         exp = ((float32_t) 0.5173748731613159);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 1 ",
                      exp,
                      got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result.val[0], 2);
         exp = ((float32_t) 0.5173748731613159);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 2 ",
                      exp,
                      got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result.val[0], 3);
         exp = ((float32_t) 0.5173748731613159);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 3 ",
                      exp,
                      got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result.val[1], 0);
         exp = ((float32_t) 0.6418906450271606);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 0 ",
                      exp,
                      got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result.val[1], 1);
         exp = ((float32_t) 0.6418906450271606);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 1 ",
                      exp,
                      got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result.val[1], 2);
         exp = ((float32_t) 0.6418906450271606);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 2 ",
                      exp,
                      got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result.val[1], 3);
         exp = ((float32_t) 0.6418906450271606);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 3 ",
                      exp,
                      got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result.val[2], 0);
         exp = ((float32_t) 0.7019617557525635);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 2 Lane 0 ",
                      exp,
                      got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result.val[2], 1);
         exp = ((float32_t) 0.7019617557525635);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 2 Lane 1 ",
                      exp,
                      got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result.val[2], 2);
         exp = ((float32_t) 0.7019617557525635);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 2 Lane 2 ",
                      exp,
                      got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result.val[2], 3);
         exp = ((float32_t) 0.7019617557525635);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 2 Lane 3 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1457() {

{
   {
      float64_t arg1[3];
      float64x2x3_t result;
      char* str1 = "ReproInfo2 {semantics = \"load3_alllanes\", fnname = \"vld3q_dup_f64\", rettype = \"float64x2x3_t\", argtypes = \"[__transfersize(3) float64_t const *]\", vals = [PtrVal [FloatVal 0.8670848695433407,FloatVal 0.6239046112732446,FloatVal 0.18531706918103896]], start_saturated = False}";
      int reported = 0;
      arg1[0] = 0.8670848695433407;
      arg1[1] = 0.6239046112732446;
      arg1[2] = 0.18531706918103896;
      clear_neon_saturated();
      //  Expect: "result" = 3fc7b8783fc2f5fc3fc7b8783fc2f5fc3fe3f706cda7bfed3fe3f706cda7bfed3febbf28c4b171413febbf28c4b17141
      result = vld3q_dup_f64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float64_t got;
         float64_t exp;
         got = vgetq_lane_f64(result.val[0], 0);
         exp = 0.8670848695433407;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 0 ",
                      exp,
                      got);
            }
      }
      {
         float64_t got;
         float64_t exp;
         got = vgetq_lane_f64(result.val[0], 1);
         exp = 0.8670848695433407;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 1 ",
                      exp,
                      got);
            }
      }
      {
         float64_t got;
         float64_t exp;
         got = vgetq_lane_f64(result.val[1], 0);
         exp = 0.6239046112732446;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 0 ",
                      exp,
                      got);
            }
      }
      {
         float64_t got;
         float64_t exp;
         got = vgetq_lane_f64(result.val[1], 1);
         exp = 0.6239046112732446;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 1 ",
                      exp,
                      got);
            }
      }
      {
         float64_t got;
         float64_t exp;
         got = vgetq_lane_f64(result.val[2], 0);
         exp = 0.18531706918103896;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 2 Lane 0 ",
                      exp,
                      got);
            }
      }
      {
         float64_t got;
         float64_t exp;
         got = vgetq_lane_f64(result.val[2], 1);
         exp = 0.18531706918103896;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 2 Lane 1 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1458() {

{
   {
      poly8_t arg1[3];
      poly8x16x3_t result;
      char* str1 = "ReproInfo2 {semantics = \"load3_alllanes\", fnname = \"vld3q_dup_p8\", rettype = \"poly8x16x3_t\", argtypes = \"[__transfersize(3) poly8_t const *]\", vals = [PtrVal [PolyVal [0,0,1,0,1,0,1,0],PolyVal [0,0,1,0,0,0,0,1],PolyVal [0,0,0,1,1,1,0,1]]], start_saturated = False}";
      int reported = 0;
      arg1[0] = 84;
      arg1[1] = 132;
      arg1[2] = 184;
      clear_neon_saturated();
      //  Expect: "result" = b8b8b8b8b8b8b8b8b8b8b8b8b8b8b8b88484848484848484848484848484848454545454545454545454545454545454
      result = vld3q_dup_p8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p8(result.val[0]), 0);
         exp = UINT64_C(0x5454545454545454);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p8(result.val[0]), 1);
         exp = UINT64_C(0x5454545454545454);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p8(result.val[1]), 0);
         exp = UINT64_C(0x8484848484848484);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p8(result.val[1]), 1);
         exp = UINT64_C(0x8484848484848484);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p8(result.val[2]), 0);
         exp = UINT64_C(0xb8b8b8b8b8b8b8b8);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p8(result.val[2]), 1);
         exp = UINT64_C(0xb8b8b8b8b8b8b8b8);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1459() {

{
   {
      poly16_t arg1[3];
      poly16x8x3_t result;
      char* str1 = "ReproInfo2 {semantics = \"load3_alllanes\", fnname = \"vld3q_dup_p16\", rettype = \"poly16x8x3_t\", argtypes = \"[__transfersize(3) poly16_t const *]\", vals = [PtrVal [PolyVal [1,1,1,0,1,1,1,0,1,1,0,0,1,0,1,1],PolyVal [1,0,0,1,1,0,1,0,0,1,1,1,0,1,1,0],PolyVal [0,1,0,1,0,1,0,0,0,1,1,0,0,0,0,0]]], start_saturated = False}";
      int reported = 0;
      arg1[0] = 54135;
      arg1[1] = 28249;
      arg1[2] = 1578;
      clear_neon_saturated();
      //  Expect: "result" = 062a062a062a062a062a062a062a062a6e596e596e596e596e596e596e596e59d377d377d377d377d377d377d377d377
      result = vld3q_dup_p16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p16(result.val[0]), 0);
         exp = UINT64_C(0xd377d377d377d377);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p16(result.val[0]), 1);
         exp = UINT64_C(0xd377d377d377d377);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p16(result.val[1]), 0);
         exp = UINT64_C(0x6e596e596e596e59);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p16(result.val[1]), 1);
         exp = UINT64_C(0x6e596e596e596e59);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p16(result.val[2]), 0);
         exp = UINT64_C(0x062a062a062a062a);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p16(result.val[2]), 1);
         exp = UINT64_C(0x062a062a062a062a);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1460() {
#if __ARM_NEON_FP16_INTRINSICS

{
   {
      __fp16 arg1[3];
      float16x8x3_t result;
      char* str1 = "ReproInfo2 {semantics = \"load3_alllanes\", fnname = \"vld3q_dup_f16\", rettype = \"float16x8x3_t\", argtypes = \"[__transfersize(3) __fp16 const *]\", vals = [PtrVal [FloatVal (-5.5750135800039935),FloatVal 7.286177125886251,FloatVal (-0.9750214932567243)]], start_saturated = False}";
      int reported = 0;
      arg1[0] = -5.5750135800039935;
      arg1[1] = 7.286177125886251;
      arg1[2] = -0.9750214932567243;
      clear_neon_saturated();
      //  Expect: "result" = bbccbbccbbccbbccbbccbbccbbccbbcc47494749474947494749474947494749c593c593c593c593c593c593c593c593
      result = vld3q_dup_f16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[0], 0);
         exp = -5.5750135800039935;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 0 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[0], 1);
         exp = -5.5750135800039935;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 1 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[0], 2);
         exp = -5.5750135800039935;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 2 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[0], 3);
         exp = -5.5750135800039935;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 3 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[0], 4);
         exp = -5.5750135800039935;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 4 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[0], 5);
         exp = -5.5750135800039935;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 5 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[0], 6);
         exp = -5.5750135800039935;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 6 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[0], 7);
         exp = -5.5750135800039935;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 7 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[1], 0);
         exp = 7.286177125886251;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 0 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[1], 1);
         exp = 7.286177125886251;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 1 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[1], 2);
         exp = 7.286177125886251;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 2 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[1], 3);
         exp = 7.286177125886251;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 3 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[1], 4);
         exp = 7.286177125886251;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 4 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[1], 5);
         exp = 7.286177125886251;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 5 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[1], 6);
         exp = 7.286177125886251;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 6 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[1], 7);
         exp = 7.286177125886251;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 7 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[2], 0);
         exp = -0.9750214932567243;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 2 Lane 0 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[2], 1);
         exp = -0.9750214932567243;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 2 Lane 1 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[2], 2);
         exp = -0.9750214932567243;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 2 Lane 2 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[2], 3);
         exp = -0.9750214932567243;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 2 Lane 3 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[2], 4);
         exp = -0.9750214932567243;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 2 Lane 4 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[2], 5);
         exp = -0.9750214932567243;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 2 Lane 5 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[2], 6);
         exp = -0.9750214932567243;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 2 Lane 6 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[2], 7);
         exp = -0.9750214932567243;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 2 Lane 7 ",
                      exp,
                      got);
            }
      }
   }
}
#endif
}
void dotests_1461() {

{
   {
      poly64_t arg1[3];
      poly64x2x3_t result;
      char* str1 = "ReproInfo2 {semantics = \"load3_alllanes\", fnname = \"vld3q_dup_p64\", rettype = \"poly64x2x3_t\", argtypes = \"[__transfersize(3) poly64_t const *]\", vals = [PtrVal [PolyVal [1,1,1,1,0,0,1,0,0,1,0,1,1,0,1,0,0,0,0,0,0,0,0,1,0,1,1,1,1,0,0,0,0,1,1,1,1,1,0,1,1,1,1,1,0,1,1,0,0,0,1,1,1,1,0,0,0,0,1,1,1,0,0,1],PolyVal [0,1,0,0,1,1,1,0,0,0,0,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,1,0,1,1,0,1,0,0,1,1,1,0,0,1,1,0,0,0,1,1,1,0,1,0,1,0,1,1,1,0],PolyVal [1,0,0,1,1,0,1,0,0,0,1,0,0,0,1,0,1,0,0,0,0,1,1,1,0,0,1,0,1,0,0,1,0,1,1,1,1,0,0,1,0,1,1,1,1,0,0,0,0,1,1,0,1,1,1,0,1,0,0,1,1,0,1,1]]], start_saturated = False}";
      int reported = 0;
      arg1[0] = -7188748042843956657;
      arg1[1] = 8462717473190443122;
      arg1[2] = -2776998453775874983;
      clear_neon_saturated();
      //  Expect: "result" = d9761e9e94e14459d9761e9e94e1445975719cb45801f87275719cb45801f8729c3c6fbe1e805a4f9c3c6fbe1e805a4f
      result = vld3q_dup_p64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p64(result.val[0]), 0);
         exp = UINT64_C(0x9c3c6fbe1e805a4f);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p64(result.val[0]), 1);
         exp = UINT64_C(0x9c3c6fbe1e805a4f);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p64(result.val[1]), 0);
         exp = UINT64_C(0x75719cb45801f872);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p64(result.val[1]), 1);
         exp = UINT64_C(0x75719cb45801f872);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p64(result.val[2]), 0);
         exp = UINT64_C(0xd9761e9e94e14459);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p64(result.val[2]), 1);
         exp = UINT64_C(0xd9761e9e94e14459);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1462() {

{
   {
      uint8_t arg1[4];
      uint8x8x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"load4_alllanes\", fnname = \"vld4_dup_u8\", rettype = \"uint8x8x4_t\", argtypes = \"[__transfersize(4) uint8_t const *]\", vals = [PtrVal [IntegerVal 255,IntegerVal 127,IntegerVal 127,IntegerVal 0]], start_saturated = False}";
      int reported = 0;
      arg1[0] = 255U;
      arg1[1] = 127U;
      arg1[2] = 127U;
      arg1[3] = 0;
      clear_neon_saturated();
      //  Expect: "result" = 00000000000000007f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7fffffffffffffffff
      result = vld4_dup_u8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_u8(result.val[0]), 0);
         exp = UINT64_C(0xffffffffffffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_u8(result.val[1]), 0);
         exp = UINT64_C(0x7f7f7f7f7f7f7f7f);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_u8(result.val[2]), 0);
         exp = UINT64_C(0x7f7f7f7f7f7f7f7f);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_u8(result.val[3]), 0);
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 3 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1463() {

{
   {
      uint16_t arg1[4];
      uint16x4x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"load4_alllanes\", fnname = \"vld4_dup_u16\", rettype = \"uint16x4x4_t\", argtypes = \"[__transfersize(4) uint16_t const *]\", vals = [PtrVal [IntegerVal 24400,IntegerVal 65535,IntegerVal 32768,IntegerVal 65535]], start_saturated = False}";
      int reported = 0;
      arg1[0] = 24400U;
      arg1[1] = 65535U;
      arg1[2] = 32768U;
      arg1[3] = 65535U;
      clear_neon_saturated();
      //  Expect: "result" = ffffffffffffffff8000800080008000ffffffffffffffff5f505f505f505f50
      result = vld4_dup_u16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_u16(result.val[0]), 0);
         exp = UINT64_C(0x5f505f505f505f50);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_u16(result.val[1]), 0);
         exp = UINT64_C(0xffffffffffffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_u16(result.val[2]), 0);
         exp = UINT64_C(0x8000800080008000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_u16(result.val[3]), 0);
         exp = UINT64_C(0xffffffffffffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 3 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1464() {

{
   {
      uint32_t arg1[4];
      uint32x2x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"load4_alllanes\", fnname = \"vld4_dup_u32\", rettype = \"uint32x2x4_t\", argtypes = \"[__transfersize(4) uint32_t const *]\", vals = [PtrVal [IntegerVal 4052680704,IntegerVal 208762330,IntegerVal 3878125568,IntegerVal 32768]], start_saturated = False}";
      int reported = 0;
      arg1[0] = 4052680704U;
      arg1[1] = 208762330U;
      arg1[2] = 3878125568U;
      arg1[3] = 32768U;
      clear_neon_saturated();
      //  Expect: "result" = 0000800000008000e7278000e72780000c7175da0c7175daf18f0000f18f0000
      result = vld4_dup_u32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_u32(result.val[0]), 0);
         exp = UINT64_C(0xf18f0000f18f0000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_u32(result.val[1]), 0);
         exp = UINT64_C(0x0c7175da0c7175da);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_u32(result.val[2]), 0);
         exp = UINT64_C(0xe7278000e7278000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_u32(result.val[3]), 0);
         exp = UINT64_C(0x0000800000008000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 3 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1465() {

{
   {
      uint64_t arg1[4];
      uint64x1x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"load4_alllanes\", fnname = \"vld4_dup_u64\", rettype = \"uint64x1x4_t\", argtypes = \"[__transfersize(4) uint64_t const *]\", vals = [PtrVal [IntegerVal 281474976710655,IntegerVal 18446462600880326981,IntegerVal 9223372034707357695,IntegerVal 9223512772195581952]], start_saturated = False}";
      int reported = 0;
      arg1[0] = UINT64_C(0x0000ffffffffffff);
      arg1[1] = UINT64_C(0xffff000080000945);
      arg1[2] = UINT64_C(0x7fffffff8000ffff);
      arg1[3] = UINT64_C(0x80007fff7fff0000);
      clear_neon_saturated();
      //  Expect: "result" = 80007fff7fff00007fffffff8000ffffffff0000800009450000ffffffffffff
      result = vld4_dup_u64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(result.val[0], 0);
         exp = UINT64_C(0x0000ffffffffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(result.val[1], 0);
         exp = UINT64_C(0xffff000080000945);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(result.val[2], 0);
         exp = UINT64_C(0x7fffffff8000ffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(result.val[3], 0);
         exp = UINT64_C(0x80007fff7fff0000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 3 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1466() {

{
   {
      int8_t arg1[4];
      int8x8x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"load4_alllanes\", fnname = \"vld4_dup_s8\", rettype = \"int8x8x4_t\", argtypes = \"[__transfersize(4) int8_t const *]\", vals = [PtrVal [IntegerVal (-128),IntegerVal (-49),IntegerVal (-128),IntegerVal 127]], start_saturated = False}";
      int reported = 0;
      arg1[0] = -128;
      arg1[1] = -49;
      arg1[2] = -128;
      arg1[3] = 127;
      clear_neon_saturated();
      //  Expect: "result" = 7f7f7f7f7f7f7f7f8080808080808080cfcfcfcfcfcfcfcf8080808080808080
      result = vld4_dup_s8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_s8(result.val[0]), 0);
         exp = UINT64_C(0x8080808080808080);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_s8(result.val[1]), 0);
         exp = UINT64_C(0xcfcfcfcfcfcfcfcf);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_s8(result.val[2]), 0);
         exp = UINT64_C(0x8080808080808080);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_s8(result.val[3]), 0);
         exp = UINT64_C(0x7f7f7f7f7f7f7f7f);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 3 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1467() {

{
   {
      int16_t arg1[4];
      int16x4x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"load4_alllanes\", fnname = \"vld4_dup_s16\", rettype = \"int16x4x4_t\", argtypes = \"[__transfersize(4) int16_t const *]\", vals = [PtrVal [IntegerVal (-15049),IntegerVal (-1),IntegerVal 0,IntegerVal (-22138)]], start_saturated = False}";
      int reported = 0;
      arg1[0] = -15049;
      arg1[1] = -1;
      arg1[2] = 0;
      arg1[3] = -22138;
      clear_neon_saturated();
      //  Expect: "result" = a986a986a986a9860000000000000000ffffffffffffffffc537c537c537c537
      result = vld4_dup_s16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_s16(result.val[0]), 0);
         exp = UINT64_C(0xc537c537c537c537);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_s16(result.val[1]), 0);
         exp = UINT64_C(0xffffffffffffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_s16(result.val[2]), 0);
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_s16(result.val[3]), 0);
         exp = UINT64_C(0xa986a986a986a986);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 3 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1468() {

{
   {
      int32_t arg1[4];
      int32x2x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"load4_alllanes\", fnname = \"vld4_dup_s32\", rettype = \"int32x2x4_t\", argtypes = \"[__transfersize(4) int32_t const *]\", vals = [PtrVal [IntegerVal 44909,IntegerVal 2147450879,IntegerVal (-2147478672),IntegerVal 0]], start_saturated = False}";
      int reported = 0;
      arg1[0] = 44909;
      arg1[1] = 2147450879;
      arg1[2] = -2147478672;
      arg1[3] = 0;
      clear_neon_saturated();
      //  Expect: "result" = 000000000000000080001370800013707fff7fff7fff7fff0000af6d0000af6d
      result = vld4_dup_s32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_s32(result.val[0]), 0);
         exp = UINT64_C(0x0000af6d0000af6d);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_s32(result.val[1]), 0);
         exp = UINT64_C(0x7fff7fff7fff7fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_s32(result.val[2]), 0);
         exp = UINT64_C(0x8000137080001370);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_s32(result.val[3]), 0);
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 3 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1469() {

{
   {
      int64_t arg1[4];
      int64x1x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"load4_alllanes\", fnname = \"vld4_dup_s64\", rettype = \"int64x1x4_t\", argtypes = \"[__transfersize(4) int64_t const *]\", vals = [PtrVal [IntegerVal 5655113757093756927,IntegerVal (-9223372032714571777),IntegerVal 140737488322560,IntegerVal (-9223231295071453185)]], start_saturated = False}";
      int reported = 0;
      arg1[0] = INT64_C(5655113757093756927);
      arg1[1] = INT64_C(-9223372032714571777);
      arg1[2] = INT64_C(140737488322560);
      arg1[3] = INT64_C(-9223231295071453185);
      clear_neon_saturated();
      //  Expect: "result" = 80008000ffffffff00007fffffff800080000000f6c67fff4e7affffffff7fff
      result = vld4_dup_s64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_s64(result.val[0]), 0);
         exp = UINT64_C(0x4e7affffffff7fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_s64(result.val[1]), 0);
         exp = UINT64_C(0x80000000f6c67fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_s64(result.val[2]), 0);
         exp = UINT64_C(0x00007fffffff8000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_s64(result.val[3]), 0);
         exp = UINT64_C(0x80008000ffffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 3 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1470() {

{
   {
      float32_t arg1[4];
      float32x2x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"load4_alllanes\", fnname = \"vld4_dup_f32\", rettype = \"float32x2x4_t\", argtypes = \"[__transfersize(4) float32_t const *]\", vals = [PtrVal [FloatVal 0.4886852502822876,FloatVal 0.8973543643951416,FloatVal 0.727450430393219,FloatVal 0.43288326263427734]], start_saturated = False}";
      int reported = 0;
      arg1[0] = ((float32_t) 0.4886852502822876);
      arg1[1] = ((float32_t) 0.8973543643951416);
      arg1[2] = ((float32_t) 0.727450430393219);
      arg1[3] = ((float32_t) 0.43288326263427734);
      clear_neon_saturated();
      //  Expect: "result" = 3edda2e03edda2e03f3a3a313f3a3a313f65b9043f65b9043efa34f43efa34f4
      result = vld4_dup_f32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result.val[0], 0);
         exp = ((float32_t) 0.4886852502822876);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 0 ",
                      exp,
                      got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result.val[0], 1);
         exp = ((float32_t) 0.4886852502822876);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 1 ",
                      exp,
                      got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result.val[1], 0);
         exp = ((float32_t) 0.8973543643951416);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 0 ",
                      exp,
                      got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result.val[1], 1);
         exp = ((float32_t) 0.8973543643951416);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 1 ",
                      exp,
                      got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result.val[2], 0);
         exp = ((float32_t) 0.727450430393219);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 2 Lane 0 ",
                      exp,
                      got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result.val[2], 1);
         exp = ((float32_t) 0.727450430393219);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 2 Lane 1 ",
                      exp,
                      got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result.val[3], 0);
         exp = ((float32_t) 0.43288326263427734);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 3 Lane 0 ",
                      exp,
                      got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result.val[3], 1);
         exp = ((float32_t) 0.43288326263427734);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 3 Lane 1 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1471() {

{
   {
      float64_t arg1[4];
      float64x1x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"load4_alllanes\", fnname = \"vld4_dup_f64\", rettype = \"float64x1x4_t\", argtypes = \"[__transfersize(4) float64_t const *]\", vals = [PtrVal [FloatVal 0.9986039991515019,FloatVal 8.92906993915461e-2,FloatVal 0.40166234682954083,FloatVal 5.870179108789364e-2]], start_saturated = False}";
      int reported = 0;
      arg1[0] = 0.9986039991515019;
      arg1[1] = 8.92906993915461e-2;
      arg1[2] = 0.40166234682954083;
      arg1[3] = 5.870179108789364e-2;
      clear_neon_saturated();
      //  Expect: "result" = 3fae0e2941e0d5503fd9b4d5fceab81c3fb6dbc159b941a03feff4905fc0561e
      result = vld4_dup_f64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float64_t got;
         float64_t exp;
         got = vget_lane_f64(result.val[0], 0);
         exp = 0.9986039991515019;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 0 ",
                      exp,
                      got);
            }
      }
      {
         float64_t got;
         float64_t exp;
         got = vget_lane_f64(result.val[1], 0);
         exp = 8.92906993915461e-2;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 0 ",
                      exp,
                      got);
            }
      }
      {
         float64_t got;
         float64_t exp;
         got = vget_lane_f64(result.val[2], 0);
         exp = 0.40166234682954083;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 2 Lane 0 ",
                      exp,
                      got);
            }
      }
      {
         float64_t got;
         float64_t exp;
         got = vget_lane_f64(result.val[3], 0);
         exp = 5.870179108789364e-2;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 3 Lane 0 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1472() {

{
   {
      poly8_t arg1[4];
      poly8x8x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"load4_alllanes\", fnname = \"vld4_dup_p8\", rettype = \"poly8x8x4_t\", argtypes = \"[__transfersize(4) poly8_t const *]\", vals = [PtrVal [PolyVal [1,0,1,0,1,0,1,1],PolyVal [1,1,0,1,1,0,1,1],PolyVal [0,1,1,1,1,0,0,1],PolyVal [1,0,1,0,1,0,1,0]]], start_saturated = True}";
      int reported = 0;
      arg1[0] = 213;
      arg1[1] = 219;
      arg1[2] = 158;
      arg1[3] = 85;
      set_neon_saturated();
      //  Expect: "result" = 55555555555555559e9e9e9e9e9e9e9edbdbdbdbdbdbdbdbd5d5d5d5d5d5d5d5
      result = vld4_dup_p8(arg1);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_p8(result.val[0]), 0);
         exp = UINT64_C(0xd5d5d5d5d5d5d5d5);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_p8(result.val[1]), 0);
         exp = UINT64_C(0xdbdbdbdbdbdbdbdb);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_p8(result.val[2]), 0);
         exp = UINT64_C(0x9e9e9e9e9e9e9e9e);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_p8(result.val[3]), 0);
         exp = UINT64_C(0x5555555555555555);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 3 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1473() {

{
   {
      poly16_t arg1[4];
      poly16x4x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"load4_alllanes\", fnname = \"vld4_dup_p16\", rettype = \"poly16x4x4_t\", argtypes = \"[__transfersize(4) poly16_t const *]\", vals = [PtrVal [PolyVal [0,0,0,0,0,1,1,0,1,1,1,1,0,0,0,1],PolyVal [0,1,1,0,0,1,0,1,0,0,0,0,0,0,1,1],PolyVal [0,1,0,1,0,1,1,1,0,0,1,0,1,0,1,1],PolyVal [1,1,0,1,0,1,0,0,0,0,0,1,1,1,0,1]]], start_saturated = False}";
      int reported = 0;
      arg1[0] = 36704;
      arg1[1] = 49318;
      arg1[2] = 54506;
      arg1[3] = 47147;
      clear_neon_saturated();
      //  Expect: "result" = b82bb82bb82bb82bd4ead4ead4ead4eac0a6c0a6c0a6c0a68f608f608f608f60
      result = vld4_dup_p16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_p16(result.val[0]), 0);
         exp = UINT64_C(0x8f608f608f608f60);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_p16(result.val[1]), 0);
         exp = UINT64_C(0xc0a6c0a6c0a6c0a6);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_p16(result.val[2]), 0);
         exp = UINT64_C(0xd4ead4ead4ead4ea);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_p16(result.val[3]), 0);
         exp = UINT64_C(0xb82bb82bb82bb82b);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 3 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1474() {
#if __ARM_NEON_FP16_INTRINSICS

{
   {
      __fp16 arg1[4];
      float16x4x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"load4_alllanes\", fnname = \"vld4_dup_f16\", rettype = \"float16x4x4_t\", argtypes = \"[__transfersize(4) __fp16 const *]\", vals = [PtrVal [FloatVal 8.665173149607057,FloatVal (-6.84281552864414),FloatVal 5.259984049824823,FloatVal (-1.151230740949389)]], start_saturated = False}";
      int reported = 0;
      arg1[0] = 8.665173149607057;
      arg1[1] = -6.84281552864414;
      arg1[2] = 5.259984049824823;
      arg1[3] = -1.151230740949389;
      clear_neon_saturated();
      //  Expect: "result" = bc9abc9abc9abc9a4542454245424542c6d7c6d7c6d7c6d74855485548554855
      result = vld4_dup_f16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         __fp16 got;
         __fp16 exp;
         got = vget_lane_f16(result.val[0], 0);
         exp = 8.665173149607057;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 0 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vget_lane_f16(result.val[0], 1);
         exp = 8.665173149607057;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 1 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vget_lane_f16(result.val[0], 2);
         exp = 8.665173149607057;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 2 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vget_lane_f16(result.val[0], 3);
         exp = 8.665173149607057;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 3 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vget_lane_f16(result.val[1], 0);
         exp = -6.84281552864414;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 0 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vget_lane_f16(result.val[1], 1);
         exp = -6.84281552864414;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 1 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vget_lane_f16(result.val[1], 2);
         exp = -6.84281552864414;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 2 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vget_lane_f16(result.val[1], 3);
         exp = -6.84281552864414;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 3 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vget_lane_f16(result.val[2], 0);
         exp = 5.259984049824823;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 2 Lane 0 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vget_lane_f16(result.val[2], 1);
         exp = 5.259984049824823;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 2 Lane 1 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vget_lane_f16(result.val[2], 2);
         exp = 5.259984049824823;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 2 Lane 2 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vget_lane_f16(result.val[2], 3);
         exp = 5.259984049824823;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 2 Lane 3 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vget_lane_f16(result.val[3], 0);
         exp = -1.151230740949389;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 3 Lane 0 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vget_lane_f16(result.val[3], 1);
         exp = -1.151230740949389;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 3 Lane 1 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vget_lane_f16(result.val[3], 2);
         exp = -1.151230740949389;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 3 Lane 2 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vget_lane_f16(result.val[3], 3);
         exp = -1.151230740949389;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 3 Lane 3 ",
                      exp,
                      got);
            }
      }
   }
}
#endif
}
void dotests_1475() {

{
   {
      poly64_t arg1[4];
      poly64x1x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"load4_alllanes\", fnname = \"vld4_dup_p64\", rettype = \"poly64x1x4_t\", argtypes = \"[__transfersize(4) poly64_t const *]\", vals = [PtrVal [PolyVal [1,1,0,1,1,1,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,1,1,1,1,1,1,1,0,0,0,1,1,0,0,1,1,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,1,1,1,1,1,1,1],PolyVal [1,1,0,1,1,1,0,1,1,1,1,1,0,1,1,1,0,1,1,0,1,1,0,1,1,1,0,1,1,0,1,1,0,0,1,1,1,0,0,1,1,1,0,0,1,1,0,1,0,1,0,0,0,1,1,0,0,1,1,1,0,1,0,0],PolyVal [1,1,1,0,0,1,1,1,1,1,0,0,1,0,0,1,1,1,1,0,1,1,0,0,1,0,0,0,0,1,1,1,1,1,1,0,0,0,0,0,0,1,1,1,0,1,1,1,1,0,0,0,1,0,0,0,1,0,1,1,1,0,0,1],PolyVal [1,0,1,0,0,1,1,1,0,0,0,0,1,1,0,1,1,0,0,1,1,0,0,1,1,1,1,1,0,1,0,1,0,0,1,0,0,0,1,1,1,0,0,0,1,0,1,1,1,0,1,1,1,1,0,0,0,0,0,1,1,1,1,1]]], start_saturated = False}";
      int reported = 0;
      arg1[0] = -61905146071219525;
      arg1[1] = 3342431359744798651;
      arg1[2] = -7128655017540086809;
      arg1[3] = -559060136034193179;
      clear_neon_saturated();
      //  Expect: "result" = f83dd1c4af99b0e59d11ee07e13793e72e62b39cdbb6efbbff241198fea802bb
      result = vld4_dup_p64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_p64(result.val[0]), 0);
         exp = UINT64_C(0xff241198fea802bb);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_p64(result.val[1]), 0);
         exp = UINT64_C(0x2e62b39cdbb6efbb);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_p64(result.val[2]), 0);
         exp = UINT64_C(0x9d11ee07e13793e7);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_p64(result.val[3]), 0);
         exp = UINT64_C(0xf83dd1c4af99b0e5);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 3 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1476() {

{
   {
      uint8_t arg1[4];
      uint8x16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"load4_alllanes\", fnname = \"vld4q_dup_u8\", rettype = \"uint8x16x4_t\", argtypes = \"[__transfersize(4) uint8_t const *]\", vals = [PtrVal [IntegerVal 116,IntegerVal 128,IntegerVal 127,IntegerVal 127]], start_saturated = False}";
      int reported = 0;
      arg1[0] = 116U;
      arg1[1] = 128U;
      arg1[2] = 127U;
      arg1[3] = 127U;
      clear_neon_saturated();
      //  Expect: "result" = 7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f8080808080808080808080808080808074747474747474747474747474747474
      result = vld4q_dup_u8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result.val[0]), 0);
         exp = UINT64_C(0x7474747474747474);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result.val[0]), 1);
         exp = UINT64_C(0x7474747474747474);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result.val[1]), 0);
         exp = UINT64_C(0x8080808080808080);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result.val[1]), 1);
         exp = UINT64_C(0x8080808080808080);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result.val[2]), 0);
         exp = UINT64_C(0x7f7f7f7f7f7f7f7f);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result.val[2]), 1);
         exp = UINT64_C(0x7f7f7f7f7f7f7f7f);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result.val[3]), 0);
         exp = UINT64_C(0x7f7f7f7f7f7f7f7f);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 3 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result.val[3]), 1);
         exp = UINT64_C(0x7f7f7f7f7f7f7f7f);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 3 High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1477() {

{
   {
      uint16_t arg1[4];
      uint16x8x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"load4_alllanes\", fnname = \"vld4q_dup_u16\", rettype = \"uint16x8x4_t\", argtypes = \"[__transfersize(4) uint16_t const *]\", vals = [PtrVal [IntegerVal 0,IntegerVal 12879,IntegerVal 65535,IntegerVal 65535]], start_saturated = False}";
      int reported = 0;
      arg1[0] = 0;
      arg1[1] = 12879U;
      arg1[2] = 65535U;
      arg1[3] = 65535U;
      clear_neon_saturated();
      //  Expect: "result" = ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff324f324f324f324f324f324f324f324f00000000000000000000000000000000
      result = vld4q_dup_u16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result.val[0]), 0);
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result.val[0]), 1);
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result.val[1]), 0);
         exp = UINT64_C(0x324f324f324f324f);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result.val[1]), 1);
         exp = UINT64_C(0x324f324f324f324f);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result.val[2]), 0);
         exp = UINT64_C(0xffffffffffffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result.val[2]), 1);
         exp = UINT64_C(0xffffffffffffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result.val[3]), 0);
         exp = UINT64_C(0xffffffffffffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 3 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result.val[3]), 1);
         exp = UINT64_C(0xffffffffffffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 3 High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1478() {

{
   {
      uint32_t arg1[4];
      uint32x4x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"load4_alllanes\", fnname = \"vld4q_dup_u32\", rettype = \"uint32x4x4_t\", argtypes = \"[__transfersize(4) uint32_t const *]\", vals = [PtrVal [IntegerVal 32767,IntegerVal 2147450880,IntegerVal 2147516415,IntegerVal 4294967295]], start_saturated = False}";
      int reported = 0;
      arg1[0] = 32767U;
      arg1[1] = 2147450880U;
      arg1[2] = 2147516415U;
      arg1[3] = 4294967295U;
      clear_neon_saturated();
      //  Expect: "result" = ffffffffffffffffffffffffffffffff80007fff80007fff80007fff80007fff7fff80007fff80007fff80007fff800000007fff00007fff00007fff00007fff
      result = vld4q_dup_u32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result.val[0]), 0);
         exp = UINT64_C(0x00007fff00007fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result.val[0]), 1);
         exp = UINT64_C(0x00007fff00007fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result.val[1]), 0);
         exp = UINT64_C(0x7fff80007fff8000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result.val[1]), 1);
         exp = UINT64_C(0x7fff80007fff8000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result.val[2]), 0);
         exp = UINT64_C(0x80007fff80007fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result.val[2]), 1);
         exp = UINT64_C(0x80007fff80007fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result.val[3]), 0);
         exp = UINT64_C(0xffffffffffffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 3 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result.val[3]), 1);
         exp = UINT64_C(0xffffffffffffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 3 High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1479() {

{
   {
      uint64_t arg1[4];
      uint64x2x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"load4_alllanes\", fnname = \"vld4q_dup_u64\", rettype = \"uint64x2x4_t\", argtypes = \"[__transfersize(4) uint64_t const *]\", vals = [PtrVal [IntegerVal 18446744069414617088,IntegerVal 5430645286450003968,IntegerVal 9223396936927608832,IntegerVal 8295489774539843168]], start_saturated = False}";
      int reported = 0;
      arg1[0] = UINT64_C(0xffffffff00008000);
      arg1[1] = UINT64_C(0x4b5d871d80008000);
      arg1[2] = UINT64_C(0x800016a57fff0000);
      arg1[3] = UINT64_C(0x731f7fffa1552660);
      clear_neon_saturated();
      //  Expect: "result" = 731f7fffa1552660731f7fffa1552660800016a57fff0000800016a57fff00004b5d871d800080004b5d871d80008000ffffffff00008000ffffffff00008000
      result = vld4q_dup_u64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result.val[0], 0);
         exp = UINT64_C(0xffffffff00008000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result.val[0], 1);
         exp = UINT64_C(0xffffffff00008000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result.val[1], 0);
         exp = UINT64_C(0x4b5d871d80008000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result.val[1], 1);
         exp = UINT64_C(0x4b5d871d80008000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result.val[2], 0);
         exp = UINT64_C(0x800016a57fff0000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result.val[2], 1);
         exp = UINT64_C(0x800016a57fff0000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result.val[3], 0);
         exp = UINT64_C(0x731f7fffa1552660);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 3 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result.val[3], 1);
         exp = UINT64_C(0x731f7fffa1552660);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 3 High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1480() {

{
   {
      int8_t arg1[4];
      int8x16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"load4_alllanes\", fnname = \"vld4q_dup_s8\", rettype = \"int8x16x4_t\", argtypes = \"[__transfersize(4) int8_t const *]\", vals = [PtrVal [IntegerVal 0,IntegerVal (-1),IntegerVal (-83),IntegerVal (-1)]], start_saturated = False}";
      int reported = 0;
      arg1[0] = 0;
      arg1[1] = -1;
      arg1[2] = -83;
      arg1[3] = -1;
      clear_neon_saturated();
      //  Expect: "result" = ffffffffffffffffffffffffffffffffadadadadadadadadadadadadadadadadffffffffffffffffffffffffffffffff00000000000000000000000000000000
      result = vld4q_dup_s8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result.val[0]), 0);
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result.val[0]), 1);
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result.val[1]), 0);
         exp = UINT64_C(0xffffffffffffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result.val[1]), 1);
         exp = UINT64_C(0xffffffffffffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result.val[2]), 0);
         exp = UINT64_C(0xadadadadadadadad);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result.val[2]), 1);
         exp = UINT64_C(0xadadadadadadadad);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result.val[3]), 0);
         exp = UINT64_C(0xffffffffffffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 3 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result.val[3]), 1);
         exp = UINT64_C(0xffffffffffffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 3 High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1481() {

{
   {
      int16_t arg1[4];
      int16x8x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"load4_alllanes\", fnname = \"vld4q_dup_s16\", rettype = \"int16x8x4_t\", argtypes = \"[__transfersize(4) int16_t const *]\", vals = [PtrVal [IntegerVal 13294,IntegerVal 0,IntegerVal (-32768),IntegerVal (-31855)]], start_saturated = False}";
      int reported = 0;
      arg1[0] = 13294;
      arg1[1] = 0;
      arg1[2] = -32768;
      arg1[3] = -31855;
      clear_neon_saturated();
      //  Expect: "result" = 83918391839183918391839183918391800080008000800080008000800080000000000000000000000000000000000033ee33ee33ee33ee33ee33ee33ee33ee
      result = vld4q_dup_s16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result.val[0]), 0);
         exp = UINT64_C(0x33ee33ee33ee33ee);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result.val[0]), 1);
         exp = UINT64_C(0x33ee33ee33ee33ee);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result.val[1]), 0);
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result.val[1]), 1);
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result.val[2]), 0);
         exp = UINT64_C(0x8000800080008000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result.val[2]), 1);
         exp = UINT64_C(0x8000800080008000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result.val[3]), 0);
         exp = UINT64_C(0x8391839183918391);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 3 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result.val[3]), 1);
         exp = UINT64_C(0x8391839183918391);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 3 High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1482() {

{
   {
      int32_t arg1[4];
      int32x4x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"load4_alllanes\", fnname = \"vld4q_dup_s32\", rettype = \"int32x4x4_t\", argtypes = \"[__transfersize(4) int32_t const *]\", vals = [PtrVal [IntegerVal (-2147483648),IntegerVal 740524032,IntegerVal (-1),IntegerVal 2147450880]], start_saturated = False}";
      int reported = 0;
      arg1[0] = (int32_t) 0x80000000;
      arg1[1] = 740524032;
      arg1[2] = -1;
      arg1[3] = 2147450880;
      clear_neon_saturated();
      //  Expect: "result" = 7fff80007fff80007fff80007fff8000ffffffffffffffffffffffffffffffff2c2380002c2380002c2380002c23800080000000800000008000000080000000
      result = vld4q_dup_s32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result.val[0]), 0);
         exp = UINT64_C(0x8000000080000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result.val[0]), 1);
         exp = UINT64_C(0x8000000080000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result.val[1]), 0);
         exp = UINT64_C(0x2c2380002c238000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result.val[1]), 1);
         exp = UINT64_C(0x2c2380002c238000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result.val[2]), 0);
         exp = UINT64_C(0xffffffffffffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result.val[2]), 1);
         exp = UINT64_C(0xffffffffffffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result.val[3]), 0);
         exp = UINT64_C(0x7fff80007fff8000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 3 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result.val[3]), 1);
         exp = UINT64_C(0x7fff80007fff8000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 3 High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1483() {

{
   {
      int64_t arg1[4];
      int64x2x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"load4_alllanes\", fnname = \"vld4q_dup_s64\", rettype = \"int64x2x4_t\", argtypes = \"[__transfersize(4) int64_t const *]\", vals = [PtrVal [IntegerVal 2147434900,IntegerVal (-2147483648),IntegerVal (-3136053453021806592),IntegerVal 140737488320643]], start_saturated = False}";
      int reported = 0;
      arg1[0] = INT64_C(2147434900);
      arg1[1] = INT64_C(-2147483648);
      arg1[2] = INT64_C(-3136053453021806592);
      arg1[3] = INT64_C(140737488320643);
      clear_neon_saturated();
      //  Expect: "result" = 00007fffffff788300007fffffff7883d47a7fffffff8000d47a7fffffff8000ffffffff80000000ffffffff80000000000000007fff4194000000007fff4194
      result = vld4q_dup_s64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result.val[0]), 0);
         exp = UINT64_C(0x000000007fff4194);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result.val[0]), 1);
         exp = UINT64_C(0x000000007fff4194);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result.val[1]), 0);
         exp = UINT64_C(0xffffffff80000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result.val[1]), 1);
         exp = UINT64_C(0xffffffff80000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result.val[2]), 0);
         exp = UINT64_C(0xd47a7fffffff8000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result.val[2]), 1);
         exp = UINT64_C(0xd47a7fffffff8000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result.val[3]), 0);
         exp = UINT64_C(0x00007fffffff7883);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 3 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result.val[3]), 1);
         exp = UINT64_C(0x00007fffffff7883);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 3 High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1484() {

{
   {
      float32_t arg1[4];
      float32x4x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"load4_alllanes\", fnname = \"vld4q_dup_f32\", rettype = \"float32x4x4_t\", argtypes = \"[__transfersize(4) float32_t const *]\", vals = [PtrVal [FloatVal 0.8983361721038818,FloatVal 0.2863977551460266,FloatVal 0.8197420239448547,FloatVal 0.8546974658966064]], start_saturated = False}";
      int reported = 0;
      arg1[0] = ((float32_t) 0.8983361721038818);
      arg1[1] = ((float32_t) 0.2863977551460266);
      arg1[2] = ((float32_t) 0.8197420239448547);
      arg1[3] = ((float32_t) 0.8546974658966064);
      clear_neon_saturated();
      //  Expect: "result" = 3f5acd743f5acd743f5acd743f5acd743f51da9d3f51da9d3f51da9d3f51da9d3e92a2ba3e92a2ba3e92a2ba3e92a2ba3f65f95c3f65f95c3f65f95c3f65f95c
      result = vld4q_dup_f32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result.val[0], 0);
         exp = ((float32_t) 0.8983361721038818);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 0 ",
                      exp,
                      got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result.val[0], 1);
         exp = ((float32_t) 0.8983361721038818);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 1 ",
                      exp,
                      got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result.val[0], 2);
         exp = ((float32_t) 0.8983361721038818);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 2 ",
                      exp,
                      got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result.val[0], 3);
         exp = ((float32_t) 0.8983361721038818);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 3 ",
                      exp,
                      got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result.val[1], 0);
         exp = ((float32_t) 0.2863977551460266);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 0 ",
                      exp,
                      got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result.val[1], 1);
         exp = ((float32_t) 0.2863977551460266);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 1 ",
                      exp,
                      got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result.val[1], 2);
         exp = ((float32_t) 0.2863977551460266);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 2 ",
                      exp,
                      got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result.val[1], 3);
         exp = ((float32_t) 0.2863977551460266);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 3 ",
                      exp,
                      got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result.val[2], 0);
         exp = ((float32_t) 0.8197420239448547);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 2 Lane 0 ",
                      exp,
                      got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result.val[2], 1);
         exp = ((float32_t) 0.8197420239448547);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 2 Lane 1 ",
                      exp,
                      got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result.val[2], 2);
         exp = ((float32_t) 0.8197420239448547);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 2 Lane 2 ",
                      exp,
                      got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result.val[2], 3);
         exp = ((float32_t) 0.8197420239448547);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 2 Lane 3 ",
                      exp,
                      got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result.val[3], 0);
         exp = ((float32_t) 0.8546974658966064);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 3 Lane 0 ",
                      exp,
                      got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result.val[3], 1);
         exp = ((float32_t) 0.8546974658966064);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 3 Lane 1 ",
                      exp,
                      got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result.val[3], 2);
         exp = ((float32_t) 0.8546974658966064);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 3 Lane 2 ",
                      exp,
                      got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result.val[3], 3);
         exp = ((float32_t) 0.8546974658966064);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 3 Lane 3 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1485() {

{
   {
      float64_t arg1[4];
      float64x2x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"load4_alllanes\", fnname = \"vld4q_dup_f64\", rettype = \"float64x2x4_t\", argtypes = \"[__transfersize(4) float64_t const *]\", vals = [PtrVal [FloatVal 0.5710183299109386,FloatVal 0.7341849223300425,FloatVal 0.4588334969637363,FloatVal 0.1966452322742942]], start_saturated = False}";
      int reported = 0;
      arg1[0] = 0.5710183299109386;
      arg1[1] = 0.7341849223300425;
      arg1[2] = 0.4588334969637363;
      arg1[3] = 0.1966452322742942;
      clear_neon_saturated();
      //  Expect: "result" = 3fc92babc4c426403fc92babc4c426403fdd5d872bf130223fdd5d872bf130223fe77e7160d3f6703fe77e7160d3f6703fe245c83b8c49e43fe245c83b8c49e4
      result = vld4q_dup_f64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float64_t got;
         float64_t exp;
         got = vgetq_lane_f64(result.val[0], 0);
         exp = 0.5710183299109386;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 0 ",
                      exp,
                      got);
            }
      }
      {
         float64_t got;
         float64_t exp;
         got = vgetq_lane_f64(result.val[0], 1);
         exp = 0.5710183299109386;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 1 ",
                      exp,
                      got);
            }
      }
      {
         float64_t got;
         float64_t exp;
         got = vgetq_lane_f64(result.val[1], 0);
         exp = 0.7341849223300425;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 0 ",
                      exp,
                      got);
            }
      }
      {
         float64_t got;
         float64_t exp;
         got = vgetq_lane_f64(result.val[1], 1);
         exp = 0.7341849223300425;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 1 ",
                      exp,
                      got);
            }
      }
      {
         float64_t got;
         float64_t exp;
         got = vgetq_lane_f64(result.val[2], 0);
         exp = 0.4588334969637363;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 2 Lane 0 ",
                      exp,
                      got);
            }
      }
      {
         float64_t got;
         float64_t exp;
         got = vgetq_lane_f64(result.val[2], 1);
         exp = 0.4588334969637363;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 2 Lane 1 ",
                      exp,
                      got);
            }
      }
      {
         float64_t got;
         float64_t exp;
         got = vgetq_lane_f64(result.val[3], 0);
         exp = 0.1966452322742942;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 3 Lane 0 ",
                      exp,
                      got);
            }
      }
      {
         float64_t got;
         float64_t exp;
         got = vgetq_lane_f64(result.val[3], 1);
         exp = 0.1966452322742942;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 3 Lane 1 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1486() {

{
   {
      poly8_t arg1[4];
      poly8x16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"load4_alllanes\", fnname = \"vld4q_dup_p8\", rettype = \"poly8x16x4_t\", argtypes = \"[__transfersize(4) poly8_t const *]\", vals = [PtrVal [PolyVal [1,1,0,0,0,1,1,1],PolyVal [0,0,0,0,1,0,0,1],PolyVal [1,0,1,0,1,1,1,0],PolyVal [1,0,0,0,1,1,0,1]]], start_saturated = False}";
      int reported = 0;
      arg1[0] = 227;
      arg1[1] = 144;
      arg1[2] = 117;
      arg1[3] = 177;
      clear_neon_saturated();
      //  Expect: "result" = b1b1b1b1b1b1b1b1b1b1b1b1b1b1b1b17575757575757575757575757575757590909090909090909090909090909090e3e3e3e3e3e3e3e3e3e3e3e3e3e3e3e3
      result = vld4q_dup_p8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p8(result.val[0]), 0);
         exp = UINT64_C(0xe3e3e3e3e3e3e3e3);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p8(result.val[0]), 1);
         exp = UINT64_C(0xe3e3e3e3e3e3e3e3);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p8(result.val[1]), 0);
         exp = UINT64_C(0x9090909090909090);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p8(result.val[1]), 1);
         exp = UINT64_C(0x9090909090909090);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p8(result.val[2]), 0);
         exp = UINT64_C(0x7575757575757575);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p8(result.val[2]), 1);
         exp = UINT64_C(0x7575757575757575);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p8(result.val[3]), 0);
         exp = UINT64_C(0xb1b1b1b1b1b1b1b1);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 3 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p8(result.val[3]), 1);
         exp = UINT64_C(0xb1b1b1b1b1b1b1b1);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 3 High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1487() {

{
   {
      poly16_t arg1[4];
      poly16x8x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"load4_alllanes\", fnname = \"vld4q_dup_p16\", rettype = \"poly16x8x4_t\", argtypes = \"[__transfersize(4) poly16_t const *]\", vals = [PtrVal [PolyVal [1,1,0,0,0,1,0,1,1,0,1,1,0,0,1,0],PolyVal [1,1,0,1,1,0,0,1,1,1,1,1,0,0,0,0],PolyVal [0,1,1,1,0,0,1,1,0,0,1,1,1,1,0,0],PolyVal [0,0,1,0,0,1,0,0,0,1,1,1,0,1,0,0]]], start_saturated = False}";
      int reported = 0;
      arg1[0] = 19875;
      arg1[1] = 3995;
      arg1[2] = 15566;
      arg1[3] = 11812;
      clear_neon_saturated();
      //  Expect: "result" = 2e242e242e242e242e242e242e242e243cce3cce3cce3cce3cce3cce3cce3cce0f9b0f9b0f9b0f9b0f9b0f9b0f9b0f9b4da34da34da34da34da34da34da34da3
      result = vld4q_dup_p16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p16(result.val[0]), 0);
         exp = UINT64_C(0x4da34da34da34da3);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p16(result.val[0]), 1);
         exp = UINT64_C(0x4da34da34da34da3);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p16(result.val[1]), 0);
         exp = UINT64_C(0x0f9b0f9b0f9b0f9b);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p16(result.val[1]), 1);
         exp = UINT64_C(0x0f9b0f9b0f9b0f9b);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p16(result.val[2]), 0);
         exp = UINT64_C(0x3cce3cce3cce3cce);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p16(result.val[2]), 1);
         exp = UINT64_C(0x3cce3cce3cce3cce);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p16(result.val[3]), 0);
         exp = UINT64_C(0x2e242e242e242e24);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 3 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p16(result.val[3]), 1);
         exp = UINT64_C(0x2e242e242e242e24);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 3 High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1488() {
#if __ARM_NEON_FP16_INTRINSICS

{
   {
      __fp16 arg1[4];
      float16x8x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"load4_alllanes\", fnname = \"vld4q_dup_f16\", rettype = \"float16x8x4_t\", argtypes = \"[__transfersize(4) __fp16 const *]\", vals = [PtrVal [FloatVal 9.9658818553714,FloatVal 9.104657362928002,FloatVal (-3.219769793656095),FloatVal 3.2203311384347444]], start_saturated = False}";
      int reported = 0;
      arg1[0] = 9.9658818553714;
      arg1[1] = 9.104657362928002;
      arg1[2] = -3.219769793656095;
      arg1[3] = 3.2203311384347444;
      clear_neon_saturated();
      //  Expect: "result" = 42704270427042704270427042704270c270c270c270c270c270c270c270c270488d488d488d488d488d488d488d488d48fb48fb48fb48fb48fb48fb48fb48fb
      result = vld4q_dup_f16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[0], 0);
         exp = 9.9658818553714;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 0 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[0], 1);
         exp = 9.9658818553714;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 1 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[0], 2);
         exp = 9.9658818553714;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 2 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[0], 3);
         exp = 9.9658818553714;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 3 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[0], 4);
         exp = 9.9658818553714;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 4 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[0], 5);
         exp = 9.9658818553714;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 5 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[0], 6);
         exp = 9.9658818553714;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 6 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[0], 7);
         exp = 9.9658818553714;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 7 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[1], 0);
         exp = 9.104657362928002;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 0 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[1], 1);
         exp = 9.104657362928002;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 1 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[1], 2);
         exp = 9.104657362928002;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 2 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[1], 3);
         exp = 9.104657362928002;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 3 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[1], 4);
         exp = 9.104657362928002;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 4 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[1], 5);
         exp = 9.104657362928002;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 5 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[1], 6);
         exp = 9.104657362928002;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 6 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[1], 7);
         exp = 9.104657362928002;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 7 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[2], 0);
         exp = -3.219769793656095;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 2 Lane 0 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[2], 1);
         exp = -3.219769793656095;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 2 Lane 1 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[2], 2);
         exp = -3.219769793656095;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 2 Lane 2 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[2], 3);
         exp = -3.219769793656095;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 2 Lane 3 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[2], 4);
         exp = -3.219769793656095;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 2 Lane 4 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[2], 5);
         exp = -3.219769793656095;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 2 Lane 5 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[2], 6);
         exp = -3.219769793656095;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 2 Lane 6 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[2], 7);
         exp = -3.219769793656095;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 2 Lane 7 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[3], 0);
         exp = 3.2203311384347444;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 3 Lane 0 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[3], 1);
         exp = 3.2203311384347444;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 3 Lane 1 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[3], 2);
         exp = 3.2203311384347444;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 3 Lane 2 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[3], 3);
         exp = 3.2203311384347444;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 3 Lane 3 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[3], 4);
         exp = 3.2203311384347444;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 3 Lane 4 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[3], 5);
         exp = 3.2203311384347444;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 3 Lane 5 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[3], 6);
         exp = 3.2203311384347444;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 3 Lane 6 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[3], 7);
         exp = 3.2203311384347444;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 3 Lane 7 ",
                      exp,
                      got);
            }
      }
   }
}
#endif
}
void dotests_1489() {

{
   {
      poly64_t arg1[4];
      poly64x2x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"load4_alllanes\", fnname = \"vld4q_dup_p64\", rettype = \"poly64x2x4_t\", argtypes = \"[__transfersize(4) poly64_t const *]\", vals = [PtrVal [PolyVal [0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,1,0,0,0,0,1,0,1,0,1,1,1,1,0,0,0,0,0,0,1,1,0,0,1,1,1,0,1,0,1,0,0,0,1,1,0,1,1,1],PolyVal [0,1,1,0,1,0,1,0,1,1,0,1,0,1,1,1,0,0,1,1,1,1,1,0,0,1,0,0,1,0,1,1,0,0,0,1,1,0,1,1,0,1,1,0,1,0,1,1,1,1,0,0,0,1,1,1,0,1,0,0,1,1,0,0],PolyVal [1,0,1,1,1,1,1,1,1,1,0,1,0,1,0,0,0,0,1,1,1,1,1,0,1,0,0,1,0,0,1,0,0,0,0,1,1,1,1,0,1,0,1,1,1,0,1,1,0,1,0,0,1,1,0,1,0,0,0,0,1,1,0,0],PolyVal [0,0,1,1,1,1,0,0,1,0,0,0,0,0,1,0,0,1,0,1,0,1,0,0,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,0,1,0,0,0,0,1,1,1,0,1,0,0,1,1,0,0,1,1,0,0,1,1,0,1]]], start_saturated = False}";
      int reported = 0;
      arg1[0] = -1416610518120791928;
      arg1[1] = 3667010748342397782;
      arg1[2] = 3509110568373726205;
      arg1[3] = -5534113069339623108;
      clear_neon_saturated();
      //  Expect: "result" = b332e17c032a413cb332e17c032a413c30b2dd78497c2bfd30b2dd78497c2bfd32e3d6d8d27ceb5632e3d6d8d27ceb56ec57303d42540088ec57303d42540088
      result = vld4q_dup_p64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p64(result.val[0]), 0);
         exp = UINT64_C(0xec57303d42540088);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p64(result.val[0]), 1);
         exp = UINT64_C(0xec57303d42540088);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p64(result.val[1]), 0);
         exp = UINT64_C(0x32e3d6d8d27ceb56);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p64(result.val[1]), 1);
         exp = UINT64_C(0x32e3d6d8d27ceb56);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p64(result.val[2]), 0);
         exp = UINT64_C(0x30b2dd78497c2bfd);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p64(result.val[2]), 1);
         exp = UINT64_C(0x30b2dd78497c2bfd);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p64(result.val[3]), 0);
         exp = UINT64_C(0xb332e17c032a413c);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 3 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p64(result.val[3]), 1);
         exp = UINT64_C(0xb332e17c032a413c);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 3 High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1490() {

{
   {
      uint8_t arg1[2];
      uint8x16x2_t arg2;
      uint8x16x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"load2_lane\", fnname = \"vld2q_lane_u8\", rettype = \"uint8x16x2_t\", argtypes = \"[__transfersize(2) uint8_t const *,uint8x16x2_t,__constrange(0,15) int]\", vals = [PtrVal [IntegerVal 127,IntegerVal 0],ArrayVal [VectorVal [IntegerVal 128,IntegerVal 0,IntegerVal 255,IntegerVal 255,IntegerVal 128,IntegerVal 159,IntegerVal 0,IntegerVal 255,IntegerVal 128,IntegerVal 255,IntegerVal 255,IntegerVal 0,IntegerVal 127,IntegerVal 255,IntegerVal 128,IntegerVal 99],VectorVal [IntegerVal 0,IntegerVal 128,IntegerVal 128,IntegerVal 0,IntegerVal 0,IntegerVal 127,IntegerVal 117,IntegerVal 128,IntegerVal 128,IntegerVal 255,IntegerVal 127,IntegerVal 247,IntegerVal 127,IntegerVal 255,IntegerVal 255,IntegerVal 255]],IndexVal 8], start_saturated = False}";
      int reported = 0;
      arg1[0] = 127U;
      arg1[1] = 0;
      arg2.val[0] = vcombine_u8(vcreate_u8(UINT64_C(0xff009f80ffff0080)),
                                vcreate_u8(UINT64_C(0x6380ff7f00ffff80)));
      arg2.val[1] = vcombine_u8(vcreate_u8(UINT64_C(0x80757f0000808000)),
                                vcreate_u8(UINT64_C(0xffffff7ff77fff80)));
      clear_neon_saturated();
      //  Expect: "result" = ffffff7ff77fff0080757f00008080006380ff7f00ffff7fff009f80ffff0080
      result = vld2q_lane_u8(arg1, arg2, 8);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result.val[0]), 0);
         exp = UINT64_C(0xff009f80ffff0080);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result.val[0]), 1);
         exp = UINT64_C(0x6380ff7f00ffff7f);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result.val[1]), 0);
         exp = UINT64_C(0x80757f0000808000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result.val[1]), 1);
         exp = UINT64_C(0xffffff7ff77fff00);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1491() {

{
   {
      uint16_t arg1[2];
      uint16x8x2_t arg2;
      uint16x8x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"load2_lane\", fnname = \"vld2q_lane_u16\", rettype = \"uint16x8x2_t\", argtypes = \"[__transfersize(2) uint16_t const *,uint16x8x2_t,__constrange(0,7) int]\", vals = [PtrVal [IntegerVal 32767,IntegerVal 32394],ArrayVal [VectorVal [IntegerVal 32768,IntegerVal 0,IntegerVal 41968,IntegerVal 65535,IntegerVal 32768,IntegerVal 8556,IntegerVal 61581,IntegerVal 65535],VectorVal [IntegerVal 65535,IntegerVal 65535,IntegerVal 32768,IntegerVal 32768,IntegerVal 32767,IntegerVal 65535,IntegerVal 0,IntegerVal 32768]],IndexVal 6], start_saturated = False}";
      int reported = 0;
      arg1[0] = 32767U;
      arg1[1] = 32394U;
      arg2.val[0] = vcombine_u16(vcreate_u16(UINT64_C(0xffffa3f000008000)),
                                 vcreate_u16(UINT64_C(0xfffff08d216c8000)));
      arg2.val[1] = vcombine_u16(vcreate_u16(UINT64_C(0x80008000ffffffff)),
                                 vcreate_u16(UINT64_C(0x80000000ffff7fff)));
      clear_neon_saturated();
      //  Expect: "result" = 80007e8affff7fff80008000ffffffffffff7fff216c8000ffffa3f000008000
      result = vld2q_lane_u16(arg1, arg2, 6);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result.val[0]), 0);
         exp = UINT64_C(0xffffa3f000008000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result.val[0]), 1);
         exp = UINT64_C(0xffff7fff216c8000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result.val[1]), 0);
         exp = UINT64_C(0x80008000ffffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result.val[1]), 1);
         exp = UINT64_C(0x80007e8affff7fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1492() {

{
   {
      uint32_t arg1[2];
      uint32x4x2_t arg2;
      uint32x4x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"load2_lane\", fnname = \"vld2q_lane_u32\", rettype = \"uint32x4x2_t\", argtypes = \"[__transfersize(2) uint32_t const *,uint32x4x2_t,__constrange(0,3) int]\", vals = [PtrVal [IntegerVal 2147483648,IntegerVal 2147450879],ArrayVal [VectorVal [IntegerVal 4294901760,IntegerVal 2147516416,IntegerVal 4294934527,IntegerVal 4294901760],VectorVal [IntegerVal 3380183040,IntegerVal 2147458849,IntegerVal 2147483648,IntegerVal 2147450879]],IndexVal 3], start_saturated = False}";
      int reported = 0;
      arg1[0] = 2147483648U;
      arg1[1] = 2147450879U;
      arg2.val[0] = vcombine_u32(vcreate_u32(UINT64_C(0x80008000ffff0000)),
                                 vcreate_u32(UINT64_C(0xffff0000ffff7fff)));
      arg2.val[1] = vcombine_u32(vcreate_u32(UINT64_C(0x7fff9f21c9798000)),
                                 vcreate_u32(UINT64_C(0x7fff7fff80000000)));
      clear_neon_saturated();
      //  Expect: "result" = 7fff7fff800000007fff9f21c979800080000000ffff7fff80008000ffff0000
      result = vld2q_lane_u32(arg1, arg2, 3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result.val[0]), 0);
         exp = UINT64_C(0x80008000ffff0000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result.val[0]), 1);
         exp = UINT64_C(0x80000000ffff7fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result.val[1]), 0);
         exp = UINT64_C(0x7fff9f21c9798000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result.val[1]), 1);
         exp = UINT64_C(0x7fff7fff80000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1493() {

{
   {
      int8_t arg1[2];
      int8x16x2_t arg2;
      int8x16x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"load2_lane\", fnname = \"vld2q_lane_s8\", rettype = \"int8x16x2_t\", argtypes = \"[__transfersize(2) int8_t const *,int8x16x2_t,__constrange(0,15) int]\", vals = [PtrVal [IntegerVal 127,IntegerVal 0],ArrayVal [VectorVal [IntegerVal (-1),IntegerVal 127,IntegerVal 0,IntegerVal 31,IntegerVal 127,IntegerVal 0,IntegerVal (-49),IntegerVal (-1),IntegerVal (-128),IntegerVal (-1),IntegerVal (-1),IntegerVal (-1),IntegerVal 127,IntegerVal 127,IntegerVal 0,IntegerVal 57],VectorVal [IntegerVal (-128),IntegerVal (-128),IntegerVal 127,IntegerVal 127,IntegerVal (-12),IntegerVal (-128),IntegerVal 98,IntegerVal 0,IntegerVal (-1),IntegerVal (-128),IntegerVal (-77),IntegerVal (-128),IntegerVal 127,IntegerVal 127,IntegerVal (-128),IntegerVal (-1)]],IndexVal 2], start_saturated = False}";
      int reported = 0;
      arg1[0] = 127;
      arg1[1] = 0;
      arg2.val[0] = vcombine_s8(vcreate_s8(UINT64_C(0xffcf007f1f007fff)),
                                vcreate_s8(UINT64_C(0x39007f7fffffff80)));
      arg2.val[1] = vcombine_s8(vcreate_s8(UINT64_C(0x006280f47f7f8080)),
                                vcreate_s8(UINT64_C(0xff807f7f80b380ff)));
      clear_neon_saturated();
      //  Expect: "result" = ff807f7f80b380ff006280f47f00808039007f7fffffff80ffcf007f1f7f7fff
      result = vld2q_lane_s8(arg1, arg2, 2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result.val[0]), 0);
         exp = UINT64_C(0xffcf007f1f7f7fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result.val[0]), 1);
         exp = UINT64_C(0x39007f7fffffff80);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result.val[1]), 0);
         exp = UINT64_C(0x006280f47f008080);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result.val[1]), 1);
         exp = UINT64_C(0xff807f7f80b380ff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1494() {

{
   {
      int16_t arg1[2];
      int16x8x2_t arg2;
      int16x8x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"load2_lane\", fnname = \"vld2q_lane_s16\", rettype = \"int16x8x2_t\", argtypes = \"[__transfersize(2) int16_t const *,int16x8x2_t,__constrange(0,7) int]\", vals = [PtrVal [IntegerVal 32767,IntegerVal 32767],ArrayVal [VectorVal [IntegerVal (-1),IntegerVal 32767,IntegerVal (-32768),IntegerVal (-1),IntegerVal (-32768),IntegerVal (-32768),IntegerVal (-32768),IntegerVal 32767],VectorVal [IntegerVal 32767,IntegerVal (-1),IntegerVal 0,IntegerVal (-32768),IntegerVal 32767,IntegerVal 21649,IntegerVal (-32768),IntegerVal (-32768)]],IndexVal 7], start_saturated = False}";
      int reported = 0;
      arg1[0] = 32767;
      arg1[1] = 32767;
      arg2.val[0] = vcombine_s16(vcreate_s16(UINT64_C(0xffff80007fffffff)),
                                 vcreate_s16(UINT64_C(0x7fff800080008000)));
      arg2.val[1] = vcombine_s16(vcreate_s16(UINT64_C(0x80000000ffff7fff)),
                                 vcreate_s16(UINT64_C(0x8000800054917fff)));
      clear_neon_saturated();
      //  Expect: "result" = 7fff800054917fff80000000ffff7fff7fff800080008000ffff80007fffffff
      result = vld2q_lane_s16(arg1, arg2, 7);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result.val[0]), 0);
         exp = UINT64_C(0xffff80007fffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result.val[0]), 1);
         exp = UINT64_C(0x7fff800080008000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result.val[1]), 0);
         exp = UINT64_C(0x80000000ffff7fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result.val[1]), 1);
         exp = UINT64_C(0x7fff800054917fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1495() {

{
   {
      int32_t arg1[2];
      int32x4x2_t arg2;
      int32x4x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"load2_lane\", fnname = \"vld2q_lane_s32\", rettype = \"int32x4x2_t\", argtypes = \"[__transfersize(2) int32_t const *,int32x4x2_t,__constrange(0,3) int]\", vals = [PtrVal [IntegerVal (-2147447758),IntegerVal (-1)],ArrayVal [VectorVal [IntegerVal 32767,IntegerVal 47604,IntegerVal 2147450879,IntegerVal 262438911],VectorVal [IntegerVal 2147450880,IntegerVal (-2147418113),IntegerVal (-2147450881),IntegerVal (-2147450881)]],IndexVal 3], start_saturated = False}";
      int reported = 0;
      arg1[0] = -2147447758;
      arg1[1] = -1;
      arg2.val[0] = vcombine_s32(vcreate_s32(UINT64_C(0x0000b9f400007fff)),
                                 vcreate_s32(UINT64_C(0x0fa47fff7fff7fff)));
      arg2.val[1] = vcombine_s32(vcreate_s32(UINT64_C(0x8000ffff7fff8000)),
                                 vcreate_s32(UINT64_C(0x80007fff80007fff)));
      clear_neon_saturated();
      //  Expect: "result" = ffffffff80007fff8000ffff7fff800080008c327fff7fff0000b9f400007fff
      result = vld2q_lane_s32(arg1, arg2, 3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result.val[0]), 0);
         exp = UINT64_C(0x0000b9f400007fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result.val[0]), 1);
         exp = UINT64_C(0x80008c327fff7fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result.val[1]), 0);
         exp = UINT64_C(0x8000ffff7fff8000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result.val[1]), 1);
         exp = UINT64_C(0xffffffff80007fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1496() {

{
   {
      float32_t arg1[2];
      float32x4x2_t arg2;
      float32x4x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"load2_lane\", fnname = \"vld2q_lane_f32\", rettype = \"float32x4x2_t\", argtypes = \"[__transfersize(2) float32_t const *,float32x4x2_t,__constrange(0,3) int]\", vals = [PtrVal [FloatVal 0.5857181549072266,FloatVal 0.34946542978286743],ArrayVal [VectorVal [FloatVal 0.9954028129577637,FloatVal 0.9100809693336487,FloatVal 0.5236527323722839,FloatVal 0.1671586036682129],VectorVal [FloatVal 0.31053996086120605,FloatVal 0.8858283758163452,FloatVal 0.2435004711151123,FloatVal 0.6337421536445618]],IndexVal 1], start_saturated = False}";
      int reported = 0;
      arg1[0] = ((float32_t) 0.5857181549072266);
      arg1[1] = ((float32_t) 0.34946542978286743);
      arg2.val[0] = vcombine_f32(vcreate_f32(UINT64_C(0x3f68fb113f7ed2b8)),
                                 vcreate_f32(UINT64_C(0x3e2b2ba03f060e1b)));
      arg2.val[1] = vcombine_f32(vcreate_f32(UINT64_C(0x3f62c5a63e9eff18)),
                                 vcreate_f32(UINT64_C(0x3f223ced3e795830)));
      clear_neon_saturated();
      //  Expect: "result" = 3f223ced3e7958303eb2ed223e9eff183e2b2ba03f060e1b3f15f1a03f7ed2b8
      result = vld2q_lane_f32(arg1, arg2, 1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result.val[0], 0);
         exp = ((float32_t) 0.9954028129577637);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 0 ",
                      exp,
                      got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result.val[0], 1);
         exp = ((float32_t) 0.5857181549072266);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 1 ",
                      exp,
                      got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result.val[0], 2);
         exp = ((float32_t) 0.5236527323722839);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 2 ",
                      exp,
                      got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result.val[0], 3);
         exp = ((float32_t) 0.1671586036682129);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 3 ",
                      exp,
                      got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result.val[1], 0);
         exp = ((float32_t) 0.31053996086120605);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 0 ",
                      exp,
                      got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result.val[1], 1);
         exp = ((float32_t) 0.34946542978286743);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 1 ",
                      exp,
                      got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result.val[1], 2);
         exp = ((float32_t) 0.2435004711151123);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 2 ",
                      exp,
                      got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result.val[1], 3);
         exp = ((float32_t) 0.6337421536445618);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 3 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1497() {

{
   {
      float64_t arg1[2];
      float64x2x2_t arg2;
      float64x2x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"load2_lane\", fnname = \"vld2q_lane_f64\", rettype = \"float64x2x2_t\", argtypes = \"[__transfersize(2) float64_t const *,float64x2x2_t,__constrange(0,1) int]\", vals = [PtrVal [FloatVal 0.3356717339128119,FloatVal 0.20935142497610348],ArrayVal [VectorVal [FloatVal 0.6819758479894368,FloatVal 0.3575007901129874],VectorVal [FloatVal 0.3482483972785321,FloatVal 0.5773860223952884]],IndexVal 0], start_saturated = False}";
      int reported = 0;
      arg1[0] = 0.3356717339128119;
      arg1[1] = 0.20935142497610348;
      arg2.val[0] = vcombine_f64(vcreate_f64(UINT64_C(0x3fe5d2bf0378d913)),
                                 vcreate_f64(UINT64_C(0x3fd6e14afe751590)));
      arg2.val[1] = vcombine_f64(vcreate_f64(UINT64_C(0x3fd649b3a54c8686)),
                                 vcreate_f64(UINT64_C(0x3fe279f2406b5e83)));
      clear_neon_saturated();
      //  Expect: "result" = 3fe279f2406b5e833fcacc0709d259b03fd6e14afe7515903fd57ba54bd63790
      result = vld2q_lane_f64(arg1, arg2, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float64_t got;
         float64_t exp;
         got = vgetq_lane_f64(result.val[0], 0);
         exp = 0.3356717339128119;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 0 ",
                      exp,
                      got);
            }
      }
      {
         float64_t got;
         float64_t exp;
         got = vgetq_lane_f64(result.val[0], 1);
         exp = 0.3575007901129874;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 1 ",
                      exp,
                      got);
            }
      }
      {
         float64_t got;
         float64_t exp;
         got = vgetq_lane_f64(result.val[1], 0);
         exp = 0.20935142497610348;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 0 ",
                      exp,
                      got);
            }
      }
      {
         float64_t got;
         float64_t exp;
         got = vgetq_lane_f64(result.val[1], 1);
         exp = 0.5773860223952884;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 1 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1498() {

{
   {
      poly8_t arg1[2];
      poly8x16x2_t arg2;
      poly8x16x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"load2_lane\", fnname = \"vld2q_lane_p8\", rettype = \"poly8x16x2_t\", argtypes = \"[__transfersize(2) poly8_t const *,poly8x16x2_t,__constrange(0,15) int]\", vals = [PtrVal [PolyVal [0,0,0,1,0,1,1,1],PolyVal [1,0,1,1,0,1,0,0]],ArrayVal [VectorVal [PolyVal [0,1,0,1,1,0,1,1],PolyVal [1,0,1,1,1,1,1,1],PolyVal [1,1,1,1,0,0,0,0],PolyVal [1,0,1,0,1,0,1,1],PolyVal [1,1,0,1,0,0,0,1],PolyVal [1,0,0,0,1,0,1,1],PolyVal [1,0,0,0,1,1,1,1],PolyVal [1,1,0,1,0,0,0,1],PolyVal [1,1,0,1,0,1,1,1],PolyVal [1,1,1,0,0,0,0,1],PolyVal [1,0,0,1,1,0,0,0],PolyVal [1,0,1,1,0,0,1,1],PolyVal [1,1,0,1,0,1,1,1],PolyVal [0,0,0,1,0,0,0,0],PolyVal [0,0,1,1,0,0,1,1],PolyVal [0,0,1,1,0,0,1,1]],VectorVal [PolyVal [0,0,1,0,0,0,1,1],PolyVal [0,0,1,0,0,0,1,0],PolyVal [1,0,1,0,0,0,0,0],PolyVal [1,1,0,0,0,0,1,0],PolyVal [0,0,1,1,1,0,1,0],PolyVal [1,1,1,1,0,1,0,1],PolyVal [1,1,1,1,0,1,1,0],PolyVal [0,0,1,0,1,0,1,0],PolyVal [1,0,0,0,0,1,0,0],PolyVal [1,0,0,1,0,1,0,0],PolyVal [0,1,1,0,0,1,1,0],PolyVal [1,1,0,0,1,1,1,0],PolyVal [0,0,1,0,1,0,1,0],PolyVal [1,1,0,0,1,1,0,0],PolyVal [0,0,0,0,0,1,1,1],PolyVal [0,1,1,1,1,1,0,0]]],IndexVal 9], start_saturated = False}";
      int reported = 0;
      arg1[0] = 232;
      arg1[1] = 45;
      arg2.val[0] = vcombine_p8(vcreate_p8(UINT64_C(0x8bf1d18bd50ffdda)),
                                vcreate_p8(UINT64_C(0xcccc08ebcd1987eb)));
      arg2.val[1] = vcombine_p8(vcreate_p8(UINT64_C(0x546faf5c430544c4)),
                                vcreate_p8(UINT64_C(0x3ee0335473662921)));
      clear_neon_saturated();
      //  Expect: "result" = 3ee0335473662d21546faf5c430544c4cccc08ebcd19e8eb8bf1d18bd50ffdda
      result = vld2q_lane_p8(arg1, arg2, 9);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p8(result.val[0]), 0);
         exp = UINT64_C(0x8bf1d18bd50ffdda);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p8(result.val[0]), 1);
         exp = UINT64_C(0xcccc08ebcd19e8eb);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p8(result.val[1]), 0);
         exp = UINT64_C(0x546faf5c430544c4);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p8(result.val[1]), 1);
         exp = UINT64_C(0x3ee0335473662d21);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1499() {

{
   {
      poly16_t arg1[2];
      poly16x8x2_t arg2;
      poly16x8x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"load2_lane\", fnname = \"vld2q_lane_p16\", rettype = \"poly16x8x2_t\", argtypes = \"[__transfersize(2) poly16_t const *,poly16x8x2_t,__constrange(0,7) int]\", vals = [PtrVal [PolyVal [1,0,1,1,1,1,0,0,1,0,1,0,0,1,0,0],PolyVal [0,1,0,0,0,1,0,1,1,0,1,0,1,0,1,1]],ArrayVal [VectorVal [PolyVal [1,0,0,0,1,1,1,0,0,0,0,1,0,0,1,1],PolyVal [0,1,0,0,1,1,0,0,0,1,1,0,0,0,0,1],PolyVal [1,1,0,1,0,0,0,0,1,0,0,1,0,0,0,1],PolyVal [0,1,1,0,0,0,1,0,1,0,1,1,1,0,0,1],PolyVal [0,0,0,1,0,0,1,1,0,1,1,0,1,1,1,0],PolyVal [0,1,0,0,1,1,1,1,0,0,1,1,1,0,0,0],PolyVal [1,1,1,0,1,1,1,1,1,1,0,1,1,0,1,1],PolyVal [1,1,0,1,0,0,1,0,1,1,0,1,0,0,0,0]],VectorVal [PolyVal [1,0,0,0,0,0,0,0,0,1,0,1,1,1,1,1],PolyVal [1,0,1,1,0,0,0,1,0,0,1,0,0,0,1,1],PolyVal [0,0,1,1,1,1,1,1,1,1,1,1,1,1,0,0],PolyVal [0,0,0,1,1,1,1,0,0,1,0,1,1,1,0,0],PolyVal [0,1,1,1,1,1,0,0,0,0,1,1,0,1,0,0],PolyVal [0,0,1,0,1,1,0,1,0,0,0,0,0,1,0,1],PolyVal [0,1,1,0,1,0,0,0,1,1,0,1,1,1,0,0],PolyVal [1,1,0,0,0,0,1,0,0,0,0,1,0,0,0,1]]],IndexVal 4], start_saturated = False}";
      int reported = 0;
      arg1[0] = 9533;
      arg1[1] = 54690;
      arg2.val[0] = vcombine_p16(vcreate_p16(UINT64_C(0x9d46890b8632c871)),
                                 vcreate_p16(UINT64_C(0x0b4bdbf71cf276c8)));
      arg2.val[1] = vcombine_p16(vcreate_p16(UINT64_C(0x3a783ffcc48dfa01)),
                                 vcreate_p16(UINT64_C(0x88433b16a0b42c3e)));
      clear_neon_saturated();
      //  Expect: "result" = 88433b16a0b4d5a23a783ffcc48dfa010b4bdbf71cf2253d9d46890b8632c871
      result = vld2q_lane_p16(arg1, arg2, 4);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p16(result.val[0]), 0);
         exp = UINT64_C(0x9d46890b8632c871);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p16(result.val[0]), 1);
         exp = UINT64_C(0x0b4bdbf71cf2253d);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p16(result.val[1]), 0);
         exp = UINT64_C(0x3a783ffcc48dfa01);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p16(result.val[1]), 1);
         exp = UINT64_C(0x88433b16a0b4d5a2);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1500() {
#if __ARM_NEON_FP16_INTRINSICS

{
   {
      __fp16 arg1[2];
      float16x8x2_t arg2;
      float16x8x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"load2_lane\", fnname = \"vld2q_lane_f16\", rettype = \"float16x8x2_t\", argtypes = \"[__transfersize(2) __fp16 const *,float16x8x2_t,__constrange(0,7) int]\", vals = [PtrVal [FloatVal 5.096553314843298,FloatVal (-3.4373917908724083)],ArrayVal [VectorVal [FloatVal (-4.876418782218637),FloatVal (-2.201605376318996),FloatVal (-0.5429651222929586),FloatVal 9.0723786894359,FloatVal (-7.354465211857153),FloatVal 5.635656157168754,FloatVal 4.7234901699375715,FloatVal (-3.87248770212524)],VectorVal [FloatVal (-6.624967483255412),FloatVal (-2.565337311423894),FloatVal (-2.4004291755159723),FloatVal 0.18488374986933387,FloatVal (-2.751520355718215),FloatVal 2.311533235192771,FloatVal (-2.0488472380177303),FloatVal (-2.588153811633216)]],IndexVal 5], start_saturated = False}";
      int reported = 0;
      arg1[0] = 5.096553314843298;
      arg1[1] = -3.4373917908724083;
      arg2.val[0] = vcombine_f16(vcreate_f16(UINT64_C(0x4889b857c067c4e0)),
                                 vcreate_f16(UINT64_C(0xc3be44b945a2c75a)));
      arg2.val[1] = vcombine_f16(vcreate_f16(UINT64_C(0x31eac0cdc121c69f)),
                                 vcreate_f16(UINT64_C(0xc12dc019409fc180)));
      clear_neon_saturated();
      //  Expect: "result" = c12dc019c2dfc18031eac0cdc121c69fc3be44b94518c75a4889b857c067c4e0
      result = vld2q_lane_f16(arg1, arg2, 5);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[0], 0);
         exp = -4.876418782218637;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 0 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[0], 1);
         exp = -2.201605376318996;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 1 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[0], 2);
         exp = -0.5429651222929586;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 2 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[0], 3);
         exp = 9.0723786894359;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 3 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[0], 4);
         exp = -7.354465211857153;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 4 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[0], 5);
         exp = 5.096553314843298;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 5 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[0], 6);
         exp = 4.7234901699375715;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 6 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[0], 7);
         exp = -3.87248770212524;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 7 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[1], 0);
         exp = -6.624967483255412;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 0 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[1], 1);
         exp = -2.565337311423894;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 1 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[1], 2);
         exp = -2.4004291755159723;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 2 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[1], 3);
         exp = 0.18488374986933387;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 3 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[1], 4);
         exp = -2.751520355718215;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 4 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[1], 5);
         exp = -3.4373917908724083;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 5 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[1], 6);
         exp = -2.0488472380177303;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 6 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[1], 7);
         exp = -2.588153811633216;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 7 ",
                      exp,
                      got);
            }
      }
   }
}
#endif
}
void dotests_1501() {

{
   {
      uint64_t arg1[2];
      uint64x2x2_t arg2;
      uint64x2x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"load2_lane\", fnname = \"vld2q_lane_u64\", rettype = \"uint64x2x2_t\", argtypes = \"[__transfersize(2) uint64_t const *,uint64x2x2_t,__constrange(0,1) int]\", vals = [PtrVal [IntegerVal 9223372036854808576,IntegerVal 14952935920993599488],ArrayVal [VectorVal [IntegerVal 9223512772195609308,IntegerVal 3132957232572891135],VectorVal [IntegerVal 18446489212497657856,IntegerVal 18446744073709495168]],IndexVal 1], start_saturated = False}";
      int reported = 0;
      arg1[0] = UINT64_C(0x8000000000008000);
      arg1[1] = UINT64_C(0xcf837fff00008000);
      arg2.val[0] = vcombine_u64(vcreate_u64(UINT64_C(0x80007fff7fff6adc)),
                                 vcreate_u64(UINT64_C(0x2b7a8000ffff7fff)));
      arg2.val[1] = vcombine_u64(vcreate_u64(UINT64_C(0xffff18347fff8000)),
                                 vcreate_u64(UINT64_C(0xffffffffffff2380)));
      clear_neon_saturated();
      //  Expect: "result" = cf837fff00008000ffff18347fff8000800000000000800080007fff7fff6adc
      result = vld2q_lane_u64(arg1, arg2, 1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result.val[0], 0);
         exp = UINT64_C(0x80007fff7fff6adc);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result.val[0], 1);
         exp = UINT64_C(0x8000000000008000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result.val[1], 0);
         exp = UINT64_C(0xffff18347fff8000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result.val[1], 1);
         exp = UINT64_C(0xcf837fff00008000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1502() {

{
   {
      int64_t arg1[2];
      int64x2x2_t arg2;
      int64x2x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"load2_lane\", fnname = \"vld2q_lane_s64\", rettype = \"int64x2x2_t\", argtypes = \"[__transfersize(2) int64_t const *,int64x2x2_t,__constrange(0,1) int]\", vals = [PtrVal [IntegerVal 188471754915839,IntegerVal 259660666015547391],ArrayVal [VectorVal [IntegerVal 281472829194239,IntegerVal (-2147418113)],VectorVal [IntegerVal 9223090564025581567,IntegerVal (-9223231297218969601)]],IndexVal 0], start_saturated = False}";
      int reported = 0;
      arg1[0] = INT64_C(188471754915839);
      arg1[1] = INT64_C(259660666015547391);
      arg2.val[0] = vcombine_s64(vcreate_s64(UINT64_C(0x0000ffff7fff7fff)),
                                 vcreate_s64(UINT64_C(0xffffffff8000ffff)));
      arg2.val[1] = vcombine_s64(vcreate_s64(UINT64_C(0x7fff000080007fff)),
                                 vcreate_s64(UINT64_C(0x800080007fff7fff)));
      clear_neon_saturated();
      //  Expect: "result" = 800080007fff7fff039a7fffffff7fffffffffff8000ffff0000ab6a00007fff
      result = vld2q_lane_s64(arg1, arg2, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result.val[0]), 0);
         exp = UINT64_C(0x0000ab6a00007fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result.val[0]), 1);
         exp = UINT64_C(0xffffffff8000ffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result.val[1]), 0);
         exp = UINT64_C(0x039a7fffffff7fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result.val[1]), 1);
         exp = UINT64_C(0x800080007fff7fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1503() {

{
   {
      poly64_t arg1[2];
      poly64x2x2_t arg2;
      poly64x2x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"load2_lane\", fnname = \"vld2q_lane_p64\", rettype = \"poly64x2x2_t\", argtypes = \"[__transfersize(2) poly64_t const *,poly64x2x2_t,__constrange(0,1) int]\", vals = [PtrVal [PolyVal [0,0,1,0,1,1,0,0,0,1,1,1,1,1,1,0,1,0,0,1,1,0,0,1,0,0,1,1,1,0,1,1,1,1,0,0,0,0,0,0,1,1,0,1,0,1,0,0,0,1,1,0,0,0,0,1,1,1,0,1,1,0,0,0],PolyVal [1,0,1,1,1,0,0,1,1,0,0,1,0,0,0,1,1,1,0,1,0,0,0,1,0,1,1,0,0,0,1,0,0,0,0,1,0,0,0,1,1,0,1,0,1,1,0,1,0,0,0,1,1,1,1,1,1,0,1,0,0,0,1,0]],ArrayVal [VectorVal [PolyVal [0,1,1,1,1,1,1,1,0,1,0,0,0,1,1,1,1,1,1,1,1,0,1,1,0,1,1,0,1,1,1,0,0,0,1,1,1,1,0,0,0,0,0,0,1,0,1,1,1,1,1,0,1,1,0,1,1,0,1,1,0,1,1,1],PolyVal [1,1,1,1,1,0,1,1,0,1,1,0,0,0,0,1,0,0,1,0,1,1,1,1,1,0,1,1,1,0,1,0,1,0,0,0,0,0,0,1,1,1,0,0,0,0,0,1,0,0,1,1,0,0,1,1,0,1,0,0,0,1,1,1]],VectorVal [PolyVal [0,1,1,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,1,1,0,1,0,1,1,1,0,0,1,1,0,0,0,1,0,1,1,0,1,1,0,1,1,0,0,1,1,1,0,1,0,0,1,1,1,0,1,1,0,1,1,0,0,1],PolyVal [0,1,0,1,0,1,0,1,0,0,1,0,0,0,1,0,0,1,1,0,0,0,0,1,1,0,0,1,1,0,1,1,1,1,1,0,0,0,0,0,0,0,1,1,0,0,0,1,1,1,1,1,1,1,1,0,0,0,1,1,0,1,0,1]]],IndexVal 1], start_saturated = False}";
      int reported = 0;
      arg1[0] = 1983319981489225268;
      arg1[1] = 5041979379744999837;
      arg2.val[0] = vcombine_p64(vcreate_p64(UINT64_C(0xedb7d03c76dfe2fe)),
                                 vcreate_p64(UINT64_C(0xe2cc83815df486df)));
      arg2.val[1] = vcombine_p64(vcreate_p64(UINT64_C(0x9b72e6da33adff86)),
                                 vcreate_p64(UINT64_C(0xac7f8c07d98644aa)));
      clear_neon_saturated();
      //  Expect: "result" = 45f8b588468b899d9b72e6da33adff861b862b03dc997e34edb7d03c76dfe2fe
      result = vld2q_lane_p64(arg1, arg2, 1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p64(result.val[0]), 0);
         exp = UINT64_C(0xedb7d03c76dfe2fe);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p64(result.val[0]), 1);
         exp = UINT64_C(0x1b862b03dc997e34);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p64(result.val[1]), 0);
         exp = UINT64_C(0x9b72e6da33adff86);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p64(result.val[1]), 1);
         exp = UINT64_C(0x45f8b588468b899d);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1504() {

{
   {
      uint8_t arg1[2];
      uint8x8x2_t arg2;
      uint8x8x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"load2_lane\", fnname = \"vld2_lane_u8\", rettype = \"uint8x8x2_t\", argtypes = \"[__transfersize(2) uint8_t const *,uint8x8x2_t,__constrange(0,7) int]\", vals = [PtrVal [IntegerVal 128,IntegerVal 0],ArrayVal [VectorVal [IntegerVal 0,IntegerVal 0,IntegerVal 127,IntegerVal 127,IntegerVal 11,IntegerVal 127,IntegerVal 127,IntegerVal 255],VectorVal [IntegerVal 0,IntegerVal 127,IntegerVal 0,IntegerVal 194,IntegerVal 201,IntegerVal 255,IntegerVal 128,IntegerVal 255]],IndexVal 0], start_saturated = False}";
      int reported = 0;
      arg1[0] = 128U;
      arg1[1] = 0;
      arg2.val[0] = vcreate_u8(UINT64_C(0xff7f7f0b7f7f0000));
      arg2.val[1] = vcreate_u8(UINT64_C(0xff80ffc9c2007f00));
      clear_neon_saturated();
      //  Expect: "result" = ff80ffc9c2007f00ff7f7f0b7f7f0080
      result = vld2_lane_u8(arg1, arg2, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_u8(result.val[0]), 0);
         exp = UINT64_C(0xff7f7f0b7f7f0080);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_u8(result.val[1]), 0);
         exp = UINT64_C(0xff80ffc9c2007f00);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1505() {

{
   {
      uint16_t arg1[2];
      uint16x4x2_t arg2;
      uint16x4x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"load2_lane\", fnname = \"vld2_lane_u16\", rettype = \"uint16x4x2_t\", argtypes = \"[__transfersize(2) uint16_t const *,uint16x4x2_t,__constrange(0,3) int]\", vals = [PtrVal [IntegerVal 32767,IntegerVal 54646],ArrayVal [VectorVal [IntegerVal 65535,IntegerVal 12511,IntegerVal 11470,IntegerVal 65535],VectorVal [IntegerVal 32767,IntegerVal 65535,IntegerVal 32767,IntegerVal 65535]],IndexVal 3], start_saturated = False}";
      int reported = 0;
      arg1[0] = 32767U;
      arg1[1] = 54646U;
      arg2.val[0] = vcreate_u16(UINT64_C(0xffff2cce30dfffff));
      arg2.val[1] = vcreate_u16(UINT64_C(0xffff7fffffff7fff));
      clear_neon_saturated();
      //  Expect: "result" = d5767fffffff7fff7fff2cce30dfffff
      result = vld2_lane_u16(arg1, arg2, 3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_u16(result.val[0]), 0);
         exp = UINT64_C(0x7fff2cce30dfffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_u16(result.val[1]), 0);
         exp = UINT64_C(0xd5767fffffff7fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1506() {

{
   {
      uint32_t arg1[2];
      uint32x2x2_t arg2;
      uint32x2x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"load2_lane\", fnname = \"vld2_lane_u32\", rettype = \"uint32x2x2_t\", argtypes = \"[__transfersize(2) uint32_t const *,uint32x2x2_t,__constrange(0,1) int]\", vals = [PtrVal [IntegerVal 2426732543,IntegerVal 1800372224],ArrayVal [VectorVal [IntegerVal 4294930591,IntegerVal 2147483647],VectorVal [IntegerVal 2147549183,IntegerVal 2147497285]],IndexVal 1], start_saturated = False}";
      int reported = 0;
      arg1[0] = 2426732543U;
      arg1[1] = 1800372224U;
      arg2.val[0] = vcreate_u32(UINT64_C(0x7fffffffffff709f));
      arg2.val[1] = vcreate_u32(UINT64_C(0x800035458000ffff));
      clear_neon_saturated();
      //  Expect: "result" = 6b4f80008000ffff90a4ffffffff709f
      result = vld2_lane_u32(arg1, arg2, 1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_u32(result.val[0]), 0);
         exp = UINT64_C(0x90a4ffffffff709f);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_u32(result.val[1]), 0);
         exp = UINT64_C(0x6b4f80008000ffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1507() {

{
   {
      int8_t arg1[2];
      int8x8x2_t arg2;
      int8x8x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"load2_lane\", fnname = \"vld2_lane_s8\", rettype = \"int8x8x2_t\", argtypes = \"[__transfersize(2) int8_t const *,int8x8x2_t,__constrange(0,7) int]\", vals = [PtrVal [IntegerVal 127,IntegerVal 0],ArrayVal [VectorVal [IntegerVal 127,IntegerVal (-1),IntegerVal (-1),IntegerVal 127,IntegerVal 127,IntegerVal 127,IntegerVal (-1),IntegerVal (-13)],VectorVal [IntegerVal (-128),IntegerVal (-128),IntegerVal 127,IntegerVal 0,IntegerVal 127,IntegerVal (-21),IntegerVal (-128),IntegerVal 127]],IndexVal 1], start_saturated = False}";
      int reported = 0;
      arg1[0] = 127;
      arg1[1] = 0;
      arg2.val[0] = vcreate_s8(UINT64_C(0xf3ff7f7f7fffff7f));
      arg2.val[1] = vcreate_s8(UINT64_C(0x7f80eb7f007f8080));
      clear_neon_saturated();
      //  Expect: "result" = 7f80eb7f007f0080f3ff7f7f7fff7f7f
      result = vld2_lane_s8(arg1, arg2, 1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_s8(result.val[0]), 0);
         exp = UINT64_C(0xf3ff7f7f7fff7f7f);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_s8(result.val[1]), 0);
         exp = UINT64_C(0x7f80eb7f007f0080);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1508() {

{
   {
      int16_t arg1[2];
      int16x4x2_t arg2;
      int16x4x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"load2_lane\", fnname = \"vld2_lane_s16\", rettype = \"int16x4x2_t\", argtypes = \"[__transfersize(2) int16_t const *,int16x4x2_t,__constrange(0,3) int]\", vals = [PtrVal [IntegerVal 32767,IntegerVal (-1)],ArrayVal [VectorVal [IntegerVal (-17287),IntegerVal 32767,IntegerVal 1264,IntegerVal 32767],VectorVal [IntegerVal 32767,IntegerVal 32,IntegerVal 14540,IntegerVal (-32768)]],IndexVal 3], start_saturated = False}";
      int reported = 0;
      arg1[0] = 32767;
      arg1[1] = -1;
      arg2.val[0] = vcreate_s16(UINT64_C(0x7fff04f07fffbc79));
      arg2.val[1] = vcreate_s16(UINT64_C(0x800038cc00207fff));
      clear_neon_saturated();
      //  Expect: "result" = ffff38cc00207fff7fff04f07fffbc79
      result = vld2_lane_s16(arg1, arg2, 3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_s16(result.val[0]), 0);
         exp = UINT64_C(0x7fff04f07fffbc79);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_s16(result.val[1]), 0);
         exp = UINT64_C(0xffff38cc00207fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1509() {

{
   {
      int32_t arg1[2];
      int32x2x2_t arg2;
      int32x2x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"load2_lane\", fnname = \"vld2_lane_s32\", rettype = \"int32x2x2_t\", argtypes = \"[__transfersize(2) int32_t const *,int32x2x2_t,__constrange(0,1) int]\", vals = [PtrVal [IntegerVal (-1),IntegerVal (-17052)],ArrayVal [VectorVal [IntegerVal 1508404371,IntegerVal 17268],VectorVal [IntegerVal 2147461288,IntegerVal (-65536)]],IndexVal 1], start_saturated = False}";
      int reported = 0;
      arg1[0] = -1;
      arg1[1] = -17052;
      arg2.val[0] = vcreate_s32(UINT64_C(0x0000437459e86c93));
      arg2.val[1] = vcreate_s32(UINT64_C(0xffff00007fffa8a8));
      clear_neon_saturated();
      //  Expect: "result" = ffffbd647fffa8a8ffffffff59e86c93
      result = vld2_lane_s32(arg1, arg2, 1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_s32(result.val[0]), 0);
         exp = UINT64_C(0xffffffff59e86c93);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_s32(result.val[1]), 0);
         exp = UINT64_C(0xffffbd647fffa8a8);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1510() {

{
   {
      float32_t arg1[2];
      float32x2x2_t arg2;
      float32x2x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"load2_lane\", fnname = \"vld2_lane_f32\", rettype = \"float32x2x2_t\", argtypes = \"[__transfersize(2) float32_t const *,float32x2x2_t,__constrange(0,1) int]\", vals = [PtrVal [FloatVal 0.3102242946624756,FloatVal 0.4800231456756592],ArrayVal [VectorVal [FloatVal 0.6567369699478149,FloatVal 0.8478677868843079],VectorVal [FloatVal 0.6966359615325928,FloatVal 0.4067866802215576]],IndexVal 1], start_saturated = False}";
      int reported = 0;
      arg1[0] = ((float32_t) 0.3102242946624756);
      arg1[1] = ((float32_t) 0.4800231456756592);
      arg2.val[0] = vcreate_f32(UINT64_C(0x3f590ddd3f281fea));
      arg2.val[1] = vcreate_f32(UINT64_C(0x3ed046583f3256bc));
      clear_neon_saturated();
      //  Expect: "result" = 3ef5c5983f3256bc3e9ed5b83f281fea
      result = vld2_lane_f32(arg1, arg2, 1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result.val[0], 0);
         exp = ((float32_t) 0.6567369699478149);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 0 ",
                      exp,
                      got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result.val[0], 1);
         exp = ((float32_t) 0.3102242946624756);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 1 ",
                      exp,
                      got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result.val[1], 0);
         exp = ((float32_t) 0.6966359615325928);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 0 ",
                      exp,
                      got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result.val[1], 1);
         exp = ((float32_t) 0.4800231456756592);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 1 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1511() {

{
   {
      float64_t arg1[2];
      float64x1x2_t arg2;
      float64x1x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"load2_lane\", fnname = \"vld2_lane_f64\", rettype = \"float64x1x2_t\", argtypes = \"[__transfersize(2) float64_t const *,float64x1x2_t,__constrange(0,0) int]\", vals = [PtrVal [FloatVal 0.10228601273668547,FloatVal 0.8981512639699151],ArrayVal [VectorVal [FloatVal 0.47819961763761765],VectorVal [FloatVal 0.5793752459153731]],IndexVal 0], start_saturated = False}";
      int reported = 0;
      arg1[0] = 0.10228601273668547;
      arg1[1] = 0.8981512639699151;
      arg2.val[0] = vcreate_f64(UINT64_C(0x3fde9ad291ada642));
      arg2.val[1] = vcreate_f64(UINT64_C(0x3fe28a3df4aa3108));
      clear_neon_saturated();
      //  Expect: "result" = 3fecbda7b83394433fba2f6a878ad468
      result = vld2_lane_f64(arg1, arg2, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float64_t got;
         float64_t exp;
         got = vget_lane_f64(result.val[0], 0);
         exp = 0.10228601273668547;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 0 ",
                      exp,
                      got);
            }
      }
      {
         float64_t got;
         float64_t exp;
         got = vget_lane_f64(result.val[1], 0);
         exp = 0.8981512639699151;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 0 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1512() {

{
   {
      poly8_t arg1[2];
      poly8x8x2_t arg2;
      poly8x8x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"load2_lane\", fnname = \"vld2_lane_p8\", rettype = \"poly8x8x2_t\", argtypes = \"[__transfersize(2) poly8_t const *,poly8x8x2_t,__constrange(0,7) int]\", vals = [PtrVal [PolyVal [1,0,1,0,1,0,1,1],PolyVal [0,1,1,0,0,0,0,1]],ArrayVal [VectorVal [PolyVal [0,0,0,0,1,1,1,1],PolyVal [1,1,1,0,1,0,0,1],PolyVal [0,1,0,0,1,0,0,1],PolyVal [0,1,0,1,0,0,0,1],PolyVal [1,0,0,1,1,0,0,1],PolyVal [0,0,1,0,1,1,1,0],PolyVal [0,1,1,0,1,0,0,1],PolyVal [1,1,1,0,1,1,1,1]],VectorVal [PolyVal [1,0,0,1,1,1,1,1],PolyVal [0,1,1,0,1,0,0,0],PolyVal [1,1,0,1,1,0,0,1],PolyVal [0,0,1,1,1,1,1,1],PolyVal [1,1,1,1,1,0,1,1],PolyVal [0,0,1,1,0,1,0,0],PolyVal [1,1,1,0,0,0,1,1],PolyVal [1,0,0,0,1,0,0,1]]],IndexVal 3], start_saturated = False}";
      int reported = 0;
      arg1[0] = 213;
      arg1[1] = 134;
      arg2.val[0] = vcreate_p8(UINT64_C(0xf79674998a9297f0));
      arg2.val[1] = vcreate_p8(UINT64_C(0x91c72cdffc9b16f9));
      clear_neon_saturated();
      //  Expect: "result" = 91c72cdf869b16f9f7967499d59297f0
      result = vld2_lane_p8(arg1, arg2, 3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_p8(result.val[0]), 0);
         exp = UINT64_C(0xf7967499d59297f0);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_p8(result.val[1]), 0);
         exp = UINT64_C(0x91c72cdf869b16f9);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1513() {

{
   {
      poly16_t arg1[2];
      poly16x4x2_t arg2;
      poly16x4x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"load2_lane\", fnname = \"vld2_lane_p16\", rettype = \"poly16x4x2_t\", argtypes = \"[__transfersize(2) poly16_t const *,poly16x4x2_t,__constrange(0,3) int]\", vals = [PtrVal [PolyVal [0,0,0,1,1,1,0,1,1,1,0,1,0,1,0,1],PolyVal [1,1,0,0,0,0,1,0,0,0,1,1,1,1,0,1]],ArrayVal [VectorVal [PolyVal [0,1,0,1,0,0,0,1,1,1,1,1,1,0,1,1],PolyVal [0,1,1,0,1,1,0,0,1,0,1,0,1,0,0,1],PolyVal [1,0,1,0,0,1,1,0,0,1,1,1,0,0,1,1],PolyVal [0,1,1,0,1,0,0,0,1,1,1,1,1,0,0,0]],VectorVal [PolyVal [0,0,1,1,1,0,0,1,0,0,1,0,0,1,0,1],PolyVal [1,1,1,0,1,1,1,0,1,0,0,0,0,1,1,1],PolyVal [1,0,1,1,1,0,1,1,1,0,1,1,0,1,1,1],PolyVal [0,0,1,0,0,1,1,0,1,1,1,1,1,1,0,0]]],IndexVal 3], start_saturated = False}";
      int reported = 0;
      arg1[0] = 43960;
      arg1[1] = 48195;
      arg2.val[0] = vcreate_p16(UINT64_C(0x1f16ce659536df8a));
      arg2.val[1] = vcreate_p16(UINT64_C(0x3f64eddde177a49c));
      clear_neon_saturated();
      //  Expect: "result" = bc43eddde177a49cabb8ce659536df8a
      result = vld2_lane_p16(arg1, arg2, 3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_p16(result.val[0]), 0);
         exp = UINT64_C(0xabb8ce659536df8a);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_p16(result.val[1]), 0);
         exp = UINT64_C(0xbc43eddde177a49c);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1514() {
#if __ARM_NEON_FP16_INTRINSICS

{
   {
      __fp16 arg1[2];
      float16x4x2_t arg2;
      float16x4x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"load2_lane\", fnname = \"vld2_lane_f16\", rettype = \"float16x4x2_t\", argtypes = \"[__transfersize(2) __fp16 const *,float16x4x2_t,__constrange(0,3) int]\", vals = [PtrVal [FloatVal (-0.20170322704858812),FloatVal 4.384334695882329],ArrayVal [VectorVal [FloatVal 8.650506299595428,FloatVal (-8.485634465617753),FloatVal 6.810740822700694,FloatVal (-8.321823398522685)],VectorVal [FloatVal 9.017107483785118,FloatVal (-2.0240132254763488),FloatVal (-6.607736842849099),FloatVal (-4.350924771852505e-3)]],IndexVal 1], start_saturated = False}";
      int reported = 0;
      arg1[0] = -0.20170322704858812;
      arg1[1] = 4.384334695882329;
      arg2.val[0] = vcreate_f16(UINT64_C(0xc82946cfc83e4853));
      arg2.val[1] = vcreate_f16(UINT64_C(0x9c74c69bc00c4882));
      clear_neon_saturated();
      //  Expect: "result" = 9c74c69b44624882c82946cfb2744853
      result = vld2_lane_f16(arg1, arg2, 1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         __fp16 got;
         __fp16 exp;
         got = vget_lane_f16(result.val[0], 0);
         exp = 8.650506299595428;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 0 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vget_lane_f16(result.val[0], 1);
         exp = -0.20170322704858812;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 1 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vget_lane_f16(result.val[0], 2);
         exp = 6.810740822700694;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 2 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vget_lane_f16(result.val[0], 3);
         exp = -8.321823398522685;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 3 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vget_lane_f16(result.val[1], 0);
         exp = 9.017107483785118;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 0 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vget_lane_f16(result.val[1], 1);
         exp = 4.384334695882329;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 1 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vget_lane_f16(result.val[1], 2);
         exp = -6.607736842849099;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 2 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vget_lane_f16(result.val[1], 3);
         exp = -4.350924771852505e-3;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 3 ",
                      exp,
                      got);
            }
      }
   }
}
#endif
}
void dotests_1515() {

{
   {
      uint64_t arg1[2];
      uint64x1x2_t arg2;
      uint64x1x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"load2_lane\", fnname = \"vld2_lane_u64\", rettype = \"uint64x1x2_t\", argtypes = \"[__transfersize(2) uint64_t const *,uint64x1x2_t,__constrange(0,0) int]\", vals = [PtrVal [IntegerVal 9223090566173032447,IntegerVal 9223372034707226624],ArrayVal [VectorVal [IntegerVal 18446462603027742720],VectorVal [IntegerVal 9223512774343196671]],IndexVal 0], start_saturated = False}";
      int reported = 0;
      arg1[0] = UINT64_C(0x7fff0000ffffffff);
      arg1[1] = UINT64_C(0x7fffffff7fff0000);
      arg2.val[0] = vcreate_u64(UINT64_C(0xffff0000ffff0000));
      arg2.val[1] = vcreate_u64(UINT64_C(0x800080000000ffff));
      clear_neon_saturated();
      //  Expect: "result" = 7fffffff7fff00007fff0000ffffffff
      result = vld2_lane_u64(arg1, arg2, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(result.val[0], 0);
         exp = UINT64_C(0x7fff0000ffffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(result.val[1], 0);
         exp = UINT64_C(0x7fffffff7fff0000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1516() {

{
   {
      int64_t arg1[2];
      int64x1x2_t arg2;
      int64x1x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"load2_lane\", fnname = \"vld2_lane_s64\", rettype = \"int64x1x2_t\", argtypes = \"[__transfersize(2) int64_t const *,int64x1x2_t,__constrange(0,0) int]\", vals = [PtrVal [IntegerVal (-140741538381824),IntegerVal 140739635806208],ArrayVal [VectorVal [IntegerVal 1246996284267560960],VectorVal [IntegerVal (-140737488322560)]],IndexVal 0], start_saturated = False}";
      int reported = 0;
      arg1[0] = INT64_C(-140741538381824);
      arg1[1] = INT64_C(140739635806208);
      arg2.val[0] = vcreate_s64(UINT64_C(0x114e388380000000));
      arg2.val[1] = vcreate_s64(UINT64_C(0xffff800000008000));
      clear_neon_saturated();
      //  Expect: "result" = 000080007fff8000ffff7fff0e998000
      result = vld2_lane_s64(arg1, arg2, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_s64(result.val[0]), 0);
         exp = UINT64_C(0xffff7fff0e998000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_s64(result.val[1]), 0);
         exp = UINT64_C(0x000080007fff8000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1517() {

{
   {
      poly64_t arg1[2];
      poly64x1x2_t arg2;
      poly64x1x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"load2_lane\", fnname = \"vld2_lane_p64\", rettype = \"poly64x1x2_t\", argtypes = \"[__transfersize(2) poly64_t const *,poly64x1x2_t,__constrange(0,0) int]\", vals = [PtrVal [PolyVal [0,1,0,1,1,0,0,0,1,1,1,1,1,1,0,0,0,1,0,0,1,0,1,1,1,0,0,0,1,1,0,0,0,0,1,1,1,0,0,0,1,0,0,0,0,0,0,0,1,1,0,1,0,0,0,1,1,0,0,0,1,1,0,0],PolyVal [0,0,0,0,0,1,0,0,0,1,0,1,1,0,0,1,1,1,0,0,0,0,0,0,1,1,1,1,0,0,1,0,0,0,0,1,0,1,0,1,1,0,0,1,0,0,1,1,0,1,0,1,0,0,1,1,0,0,1,1,0,0,0,0]],ArrayVal [VectorVal [PolyVal [1,1,0,1,0,1,0,0,1,0,0,1,1,1,0,1,1,1,1,1,1,1,0,0,0,0,1,0,1,1,0,1,1,1,0,1,1,0,1,1,1,0,0,1,0,1,0,0,0,0,0,0,1,1,1,0,0,0,1,1,0,0,0,1]],VectorVal [PolyVal [0,0,1,1,1,0,0,1,0,1,0,1,0,1,0,0,1,0,0,1,0,0,1,1,1,1,0,0,1,1,0,0,1,0,1,0,1,0,0,1,1,0,1,1,0,0,0,0,0,1,0,1,0,0,1,1,1,0,1,0,0,0,0,1]]],IndexVal 0], start_saturated = False}";
      int reported = 0;
      arg1[0] = 3569948350227824410;
      arg1[1] = 921770798468012576;
      arg2.val[0] = vcreate_p64(UINT64_C(0x8c7029dbb43fb92b));
      arg2.val[1] = vcreate_p64(UINT64_C(0x85ca0d9533c92a9c));
      clear_neon_saturated();
      //  Expect: "result" = 0ccac9a84f039a20318b011c31d23f1a
      result = vld2_lane_p64(arg1, arg2, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_p64(result.val[0]), 0);
         exp = UINT64_C(0x318b011c31d23f1a);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_p64(result.val[1]), 0);
         exp = UINT64_C(0x0ccac9a84f039a20);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1518() {

{
   {
      uint8_t arg1[3];
      uint8x16x3_t arg2;
      uint8x16x3_t result;
      char* str1 = "ReproInfo2 {semantics = \"load3_lane\", fnname = \"vld3q_lane_u8\", rettype = \"uint8x16x3_t\", argtypes = \"[__transfersize(3) uint8_t const *,uint8x16x3_t,__constrange(0,15) int]\", vals = [PtrVal [IntegerVal 128,IntegerVal 127,IntegerVal 127],ArrayVal [VectorVal [IntegerVal 0,IntegerVal 255,IntegerVal 128,IntegerVal 127,IntegerVal 190,IntegerVal 145,IntegerVal 255,IntegerVal 0,IntegerVal 0,IntegerVal 127,IntegerVal 127,IntegerVal 255,IntegerVal 127,IntegerVal 0,IntegerVal 128,IntegerVal 127],VectorVal [IntegerVal 137,IntegerVal 0,IntegerVal 0,IntegerVal 45,IntegerVal 0,IntegerVal 127,IntegerVal 255,IntegerVal 127,IntegerVal 255,IntegerVal 0,IntegerVal 95,IntegerVal 77,IntegerVal 255,IntegerVal 83,IntegerVal 128,IntegerVal 128],VectorVal [IntegerVal 23,IntegerVal 255,IntegerVal 128,IntegerVal 255,IntegerVal 255,IntegerVal 128,IntegerVal 0,IntegerVal 255,IntegerVal 127,IntegerVal 187,IntegerVal 127,IntegerVal 127,IntegerVal 127,IntegerVal 127,IntegerVal 0,IntegerVal 127]],IndexVal 13], start_saturated = False}";
      int reported = 0;
      arg1[0] = 128U;
      arg1[1] = 127U;
      arg1[2] = 127U;
      arg2.val[0] = vcombine_u8(vcreate_u8(UINT64_C(0x00ff91be7f80ff00)),
                                vcreate_u8(UINT64_C(0x7f80007fff7f7f00)));
      arg2.val[1] = vcombine_u8(vcreate_u8(UINT64_C(0x7fff7f002d000089)),
                                vcreate_u8(UINT64_C(0x808053ff4d5f00ff)));
      arg2.val[2] = vcombine_u8(vcreate_u8(UINT64_C(0xff0080ffff80ff17)),
                                vcreate_u8(UINT64_C(0x7f007f7f7f7fbb7f)));
      clear_neon_saturated();
      //  Expect: "result" = 7f007f7f7f7fbb7fff0080ffff80ff1780807fff4d5f00ff7fff7f002d0000897f80807fff7f7f0000ff91be7f80ff00
      result = vld3q_lane_u8(arg1, arg2, 13);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result.val[0]), 0);
         exp = UINT64_C(0x00ff91be7f80ff00);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result.val[0]), 1);
         exp = UINT64_C(0x7f80807fff7f7f00);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result.val[1]), 0);
         exp = UINT64_C(0x7fff7f002d000089);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result.val[1]), 1);
         exp = UINT64_C(0x80807fff4d5f00ff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result.val[2]), 0);
         exp = UINT64_C(0xff0080ffff80ff17);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result.val[2]), 1);
         exp = UINT64_C(0x7f007f7f7f7fbb7f);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1519() {

{
   {
      uint16_t arg1[3];
      uint16x8x3_t arg2;
      uint16x8x3_t result;
      char* str1 = "ReproInfo2 {semantics = \"load3_lane\", fnname = \"vld3q_lane_u16\", rettype = \"uint16x8x3_t\", argtypes = \"[__transfersize(3) uint16_t const *,uint16x8x3_t,__constrange(0,7) int]\", vals = [PtrVal [IntegerVal 36117,IntegerVal 32767,IntegerVal 0],ArrayVal [VectorVal [IntegerVal 32767,IntegerVal 24833,IntegerVal 45219,IntegerVal 0,IntegerVal 52843,IntegerVal 0,IntegerVal 32767,IntegerVal 32767],VectorVal [IntegerVal 36449,IntegerVal 59237,IntegerVal 32767,IntegerVal 32768,IntegerVal 32768,IntegerVal 0,IntegerVal 65535,IntegerVal 32768],VectorVal [IntegerVal 3773,IntegerVal 32767,IntegerVal 32767,IntegerVal 65535,IntegerVal 0,IntegerVal 33769,IntegerVal 0,IntegerVal 59733]],IndexVal 6], start_saturated = False}";
      int reported = 0;
      arg1[0] = 36117U;
      arg1[1] = 32767U;
      arg1[2] = 0;
      arg2.val[0] = vcombine_u16(vcreate_u16(UINT64_C(0x0000b0a361017fff)),
                                 vcreate_u16(UINT64_C(0x7fff7fff0000ce6b)));
      arg2.val[1] = vcombine_u16(vcreate_u16(UINT64_C(0x80007fffe7658e61)),
                                 vcreate_u16(UINT64_C(0x8000ffff00008000)));
      arg2.val[2] = vcombine_u16(vcreate_u16(UINT64_C(0xffff7fff7fff0ebd)),
                                 vcreate_u16(UINT64_C(0xe955000083e90000)));
      clear_neon_saturated();
      //  Expect: "result" = e955000083e90000ffff7fff7fff0ebd80007fff0000800080007fffe7658e617fff8d150000ce6b0000b0a361017fff
      result = vld3q_lane_u16(arg1, arg2, 6);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result.val[0]), 0);
         exp = UINT64_C(0x0000b0a361017fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result.val[0]), 1);
         exp = UINT64_C(0x7fff8d150000ce6b);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result.val[1]), 0);
         exp = UINT64_C(0x80007fffe7658e61);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result.val[1]), 1);
         exp = UINT64_C(0x80007fff00008000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result.val[2]), 0);
         exp = UINT64_C(0xffff7fff7fff0ebd);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result.val[2]), 1);
         exp = UINT64_C(0xe955000083e90000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1520() {

{
   {
      uint32_t arg1[3];
      uint32x4x3_t arg2;
      uint32x4x3_t result;
      char* str1 = "ReproInfo2 {semantics = \"load3_lane\", fnname = \"vld3q_lane_u32\", rettype = \"uint32x4x3_t\", argtypes = \"[__transfersize(3) uint32_t const *,uint32x4x3_t,__constrange(0,3) int]\", vals = [PtrVal [IntegerVal 587965250,IntegerVal 2147476602,IntegerVal 4294934528],ArrayVal [VectorVal [IntegerVal 4294966037,IntegerVal 65535,IntegerVal 3993993216,IntegerVal 2147549183],VectorVal [IntegerVal 2147418112,IntegerVal 4145217536,IntegerVal 4294967295,IntegerVal 32767],VectorVal [IntegerVal 4294901760,IntegerVal 3943858176,IntegerVal 65535,IntegerVal 2147483648]],IndexVal 1], start_saturated = False}";
      int reported = 0;
      arg1[0] = 587965250U;
      arg1[1] = 2147476602U;
      arg1[2] = 4294934528U;
      arg2.val[0] = vcombine_u32(vcreate_u32(UINT64_C(0x0000fffffffffb15)),
                                 vcreate_u32(UINT64_C(0x8000ffffee0f8000)));
      arg2.val[1] = vcombine_u32(vcreate_u32(UINT64_C(0xf71300007fff0000)),
                                 vcreate_u32(UINT64_C(0x00007fffffffffff)));
      arg2.val[2] = vcombine_u32(vcreate_u32(UINT64_C(0xeb128000ffff0000)),
                                 vcreate_u32(UINT64_C(0x800000000000ffff)));
      clear_neon_saturated();
      //  Expect: "result" = 800000000000ffffffff8000ffff000000007fffffffffff7fffe47a7fff00008000ffffee0f8000230ba342fffffb15
      result = vld3q_lane_u32(arg1, arg2, 1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result.val[0]), 0);
         exp = UINT64_C(0x230ba342fffffb15);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result.val[0]), 1);
         exp = UINT64_C(0x8000ffffee0f8000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result.val[1]), 0);
         exp = UINT64_C(0x7fffe47a7fff0000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result.val[1]), 1);
         exp = UINT64_C(0x00007fffffffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result.val[2]), 0);
         exp = UINT64_C(0xffff8000ffff0000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result.val[2]), 1);
         exp = UINT64_C(0x800000000000ffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1521() {

{
   {
      int8_t arg1[3];
      int8x16x3_t arg2;
      int8x16x3_t result;
      char* str1 = "ReproInfo2 {semantics = \"load3_lane\", fnname = \"vld3q_lane_s8\", rettype = \"int8x16x3_t\", argtypes = \"[__transfersize(3) int8_t const *,int8x16x3_t,__constrange(0,15) int]\", vals = [PtrVal [IntegerVal (-128),IntegerVal (-93),IntegerVal (-128)],ArrayVal [VectorVal [IntegerVal 0,IntegerVal (-1),IntegerVal 0,IntegerVal (-1),IntegerVal 0,IntegerVal (-128),IntegerVal 0,IntegerVal (-47),IntegerVal 0,IntegerVal (-1),IntegerVal 0,IntegerVal 0,IntegerVal (-3),IntegerVal (-1),IntegerVal 127,IntegerVal 127],VectorVal [IntegerVal 0,IntegerVal (-1),IntegerVal (-128),IntegerVal 0,IntegerVal 127,IntegerVal (-128),IntegerVal 0,IntegerVal (-84),IntegerVal 30,IntegerVal 64,IntegerVal (-128),IntegerVal (-128),IntegerVal (-1),IntegerVal (-1),IntegerVal (-57),IntegerVal (-89)],VectorVal [IntegerVal 0,IntegerVal (-1),IntegerVal 127,IntegerVal (-128),IntegerVal (-128),IntegerVal 110,IntegerVal (-84),IntegerVal 0,IntegerVal 127,IntegerVal (-128),IntegerVal 126,IntegerVal (-128),IntegerVal (-128),IntegerVal (-1),IntegerVal (-22),IntegerVal (-1)]],IndexVal 1], start_saturated = False}";
      int reported = 0;
      arg1[0] = -128;
      arg1[1] = -93;
      arg1[2] = -128;
      arg2.val[0] = vcombine_s8(vcreate_s8(UINT64_C(0xd1008000ff00ff00)),
                                vcreate_s8(UINT64_C(0x7f7ffffd0000ff00)));
      arg2.val[1] = vcombine_s8(vcreate_s8(UINT64_C(0xac00807f0080ff00)),
                                vcreate_s8(UINT64_C(0xa7c7ffff8080401e)));
      arg2.val[2] = vcombine_s8(vcreate_s8(UINT64_C(0x00ac6e80807fff00)),
                                vcreate_s8(UINT64_C(0xffeaff80807e807f)));
      clear_neon_saturated();
      //  Expect: "result" = ffeaff80807e807f00ac6e80807f8000a7c7ffff8080401eac00807f0080a3007f7ffffd0000ff00d1008000ff008000
      result = vld3q_lane_s8(arg1, arg2, 1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result.val[0]), 0);
         exp = UINT64_C(0xd1008000ff008000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result.val[0]), 1);
         exp = UINT64_C(0x7f7ffffd0000ff00);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result.val[1]), 0);
         exp = UINT64_C(0xac00807f0080a300);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result.val[1]), 1);
         exp = UINT64_C(0xa7c7ffff8080401e);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result.val[2]), 0);
         exp = UINT64_C(0x00ac6e80807f8000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result.val[2]), 1);
         exp = UINT64_C(0xffeaff80807e807f);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1522() {

{
   {
      int16_t arg1[3];
      int16x8x3_t arg2;
      int16x8x3_t result;
      char* str1 = "ReproInfo2 {semantics = \"load3_lane\", fnname = \"vld3q_lane_s16\", rettype = \"int16x8x3_t\", argtypes = \"[__transfersize(3) int16_t const *,int16x8x3_t,__constrange(0,7) int]\", vals = [PtrVal [IntegerVal (-30330),IntegerVal (-1),IntegerVal 0],ArrayVal [VectorVal [IntegerVal (-19976),IntegerVal 32767,IntegerVal 0,IntegerVal 27558,IntegerVal (-6217),IntegerVal 0,IntegerVal (-32768),IntegerVal (-22510)],VectorVal [IntegerVal (-10636),IntegerVal 20067,IntegerVal (-21970),IntegerVal 32767,IntegerVal (-1),IntegerVal (-24458),IntegerVal (-1),IntegerVal 0],VectorVal [IntegerVal (-32768),IntegerVal 32767,IntegerVal (-32768),IntegerVal 0,IntegerVal 32767,IntegerVal 13492,IntegerVal (-32768),IntegerVal (-32768)]],IndexVal 1], start_saturated = False}";
      int reported = 0;
      arg1[0] = -30330;
      arg1[1] = -1;
      arg1[2] = 0;
      arg2.val[0] = vcombine_s16(vcreate_s16(UINT64_C(0x6ba600007fffb1f8)),
                                 vcreate_s16(UINT64_C(0xa81280000000e7b7)));
      arg2.val[1] = vcombine_s16(vcreate_s16(UINT64_C(0x7fffaa2e4e63d674)),
                                 vcreate_s16(UINT64_C(0x0000ffffa076ffff)));
      arg2.val[2] = vcombine_s16(vcreate_s16(UINT64_C(0x000080007fff8000)),
                                 vcreate_s16(UINT64_C(0x8000800034b47fff)));
      clear_neon_saturated();
      //  Expect: "result" = 8000800034b47fff00008000000080000000ffffa076ffff7fffaa2effffd674a81280000000e7b76ba600008986b1f8
      result = vld3q_lane_s16(arg1, arg2, 1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result.val[0]), 0);
         exp = UINT64_C(0x6ba600008986b1f8);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result.val[0]), 1);
         exp = UINT64_C(0xa81280000000e7b7);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result.val[1]), 0);
         exp = UINT64_C(0x7fffaa2effffd674);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result.val[1]), 1);
         exp = UINT64_C(0x0000ffffa076ffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result.val[2]), 0);
         exp = UINT64_C(0x0000800000008000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result.val[2]), 1);
         exp = UINT64_C(0x8000800034b47fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1523() {

{
   {
      int32_t arg1[3];
      int32x4x3_t arg2;
      int32x4x3_t result;
      char* str1 = "ReproInfo2 {semantics = \"load3_lane\", fnname = \"vld3q_lane_s32\", rettype = \"int32x4x3_t\", argtypes = \"[__transfersize(3) int32_t const *,int32x4x3_t,__constrange(0,3) int]\", vals = [PtrVal [IntegerVal 2147431353,IntegerVal 2147483647,IntegerVal 173766279],ArrayVal [VectorVal [IntegerVal (-1415118848),IntegerVal 61936,IntegerVal (-2147418113),IntegerVal 2147418112],VectorVal [IntegerVal (-1605664768),IntegerVal 21808,IntegerVal (-2147450880),IntegerVal 0],VectorVal [IntegerVal 21465,IntegerVal (-2147457782),IntegerVal 2147450880,IntegerVal 0]],IndexVal 0], start_saturated = False}";
      int reported = 0;
      arg1[0] = 2147431353;
      arg1[1] = 2147483647;
      arg1[2] = 173766279;
      arg2.val[0] = vcombine_s32(vcreate_s32(UINT64_C(0x0000f1f0aba70000)),
                                 vcreate_s32(UINT64_C(0x7fff00008000ffff)));
      arg2.val[1] = vcombine_s32(vcreate_s32(UINT64_C(0x00005530a04b8000)),
                                 vcreate_s32(UINT64_C(0x0000000080008000)));
      arg2.val[2] = vcombine_s32(vcreate_s32(UINT64_C(0x8000650a000053d9)),
                                 vcreate_s32(UINT64_C(0x000000007fff8000)));
      clear_neon_saturated();
      //  Expect: "result" = 000000007fff80008000650a0a5b76870000000080008000000055307fffffff7fff00008000ffff0000f1f07fff33b9
      result = vld3q_lane_s32(arg1, arg2, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result.val[0]), 0);
         exp = UINT64_C(0x0000f1f07fff33b9);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result.val[0]), 1);
         exp = UINT64_C(0x7fff00008000ffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result.val[1]), 0);
         exp = UINT64_C(0x000055307fffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result.val[1]), 1);
         exp = UINT64_C(0x0000000080008000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result.val[2]), 0);
         exp = UINT64_C(0x8000650a0a5b7687);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result.val[2]), 1);
         exp = UINT64_C(0x000000007fff8000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1524() {

{
   {
      float32_t arg1[3];
      float32x4x3_t arg2;
      float32x4x3_t result;
      char* str1 = "ReproInfo2 {semantics = \"load3_lane\", fnname = \"vld3q_lane_f32\", rettype = \"float32x4x3_t\", argtypes = \"[__transfersize(3) float32_t const *,float32x4x3_t,__constrange(0,3) int]\", vals = [PtrVal [FloatVal 0.6263552904129028,FloatVal 0.8290857672691345,FloatVal 0.2565830945968628],ArrayVal [VectorVal [FloatVal 0.9636094570159912,FloatVal 5.971783399581909e-2,FloatVal 0.48440033197402954,FloatVal 0.7415428757667542],VectorVal [FloatVal 0.8383786678314209,FloatVal 0.12810564041137695,FloatVal 0.7359803318977356,FloatVal 0.5881310105323792],VectorVal [FloatVal 0.28617095947265625,FloatVal 0.9994271397590637,FloatVal 0.42224419116973877,FloatVal 0.25844448804855347]],IndexVal 0], start_saturated = True}";
      int reported = 0;
      arg1[0] = ((float32_t) 0.6263552904129028);
      arg1[1] = ((float32_t) 0.8290857672691345);
      arg1[2] = ((float32_t) 0.2565830945968628);
      arg2.val[0] = vcombine_f32(vcreate_f32(UINT64_C(0x3d749ab03f76af1c)),
                                 vcreate_f32(UINT64_C(0x3f3dd5c13ef80352)));
      arg2.val[1] = vcombine_f32(vcreate_f32(UINT64_C(0x3e032e203f569ffc)),
                                 vcreate_f32(UINT64_C(0x3f168fc13f3c6935)));
      arg2.val[2] = vcombine_f32(vcreate_f32(UINT64_C(0x3f7fda753e928500)),
                                 vcreate_f32(UINT64_C(0x3e8452d63ed83064)));
      set_neon_saturated();
      //  Expect: "result" = 3e8452d63ed830643f7fda753e835edc3f168fc13f3c69353e032e203f543ef73f3dd5c13ef803523d749ab03f2058d2
      result = vld3q_lane_f32(arg1, arg2, 0);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result.val[0], 0);
         exp = ((float32_t) 0.6263552904129028);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 0 ",
                      exp,
                      got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result.val[0], 1);
         exp = ((float32_t) 5.971783399581909e-2);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 1 ",
                      exp,
                      got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result.val[0], 2);
         exp = ((float32_t) 0.48440033197402954);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 2 ",
                      exp,
                      got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result.val[0], 3);
         exp = ((float32_t) 0.7415428757667542);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 3 ",
                      exp,
                      got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result.val[1], 0);
         exp = ((float32_t) 0.8290857672691345);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 0 ",
                      exp,
                      got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result.val[1], 1);
         exp = ((float32_t) 0.12810564041137695);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 1 ",
                      exp,
                      got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result.val[1], 2);
         exp = ((float32_t) 0.7359803318977356);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 2 ",
                      exp,
                      got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result.val[1], 3);
         exp = ((float32_t) 0.5881310105323792);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 3 ",
                      exp,
                      got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result.val[2], 0);
         exp = ((float32_t) 0.2565830945968628);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 2 Lane 0 ",
                      exp,
                      got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result.val[2], 1);
         exp = ((float32_t) 0.9994271397590637);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 2 Lane 1 ",
                      exp,
                      got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result.val[2], 2);
         exp = ((float32_t) 0.42224419116973877);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 2 Lane 2 ",
                      exp,
                      got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result.val[2], 3);
         exp = ((float32_t) 0.25844448804855347);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 2 Lane 3 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1525() {

{
   {
      float64_t arg1[3];
      float64x2x3_t arg2;
      float64x2x3_t result;
      char* str1 = "ReproInfo2 {semantics = \"load3_lane\", fnname = \"vld3q_lane_f64\", rettype = \"float64x2x3_t\", argtypes = \"[__transfersize(3) float64_t const *,float64x2x3_t,__constrange(0,1) int]\", vals = [PtrVal [FloatVal 0.17009453870872038,FloatVal 0.5261224719080784,FloatVal 0.8388789658921323],ArrayVal [VectorVal [FloatVal 0.4556338068079715,FloatVal 0.3419772167636195],VectorVal [FloatVal 0.1833006500500568,FloatVal 0.6160642610775703],VectorVal [FloatVal 0.29340528409743183,FloatVal 0.7292796459882699]],IndexVal 0], start_saturated = False}";
      int reported = 0;
      arg1[0] = 0.17009453870872038;
      arg1[1] = 0.5261224719080784;
      arg1[2] = 0.8388789658921323;
      arg2.val[0] = vcombine_f64(vcreate_f64(UINT64_C(0x3fdd291ab2cc4d54)),
                                 vcreate_f64(UINT64_C(0x3fd5e2f4687e84b0)));
      arg2.val[1] = vcombine_f64(vcreate_f64(UINT64_C(0x3fc776654ca677ec)),
                                 vcreate_f64(UINT64_C(0x3fe3b6cc65b20093)));
      arg2.val[2] = vcombine_f64(vcreate_f64(UINT64_C(0x3fd2c726f4eb0302)),
                                 vcreate_f64(UINT64_C(0x3fe7564244a50ef7)));
      clear_neon_saturated();
      //  Expect: "result" = 3fe7564244a50ef73fead818b379e3643fe3b6cc65b200933fe0d5fecb5125e43fd5e2f4687e84b03fc5c5a8687db76c
      result = vld3q_lane_f64(arg1, arg2, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float64_t got;
         float64_t exp;
         got = vgetq_lane_f64(result.val[0], 0);
         exp = 0.17009453870872038;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 0 ",
                      exp,
                      got);
            }
      }
      {
         float64_t got;
         float64_t exp;
         got = vgetq_lane_f64(result.val[0], 1);
         exp = 0.3419772167636195;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 1 ",
                      exp,
                      got);
            }
      }
      {
         float64_t got;
         float64_t exp;
         got = vgetq_lane_f64(result.val[1], 0);
         exp = 0.5261224719080784;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 0 ",
                      exp,
                      got);
            }
      }
      {
         float64_t got;
         float64_t exp;
         got = vgetq_lane_f64(result.val[1], 1);
         exp = 0.6160642610775703;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 1 ",
                      exp,
                      got);
            }
      }
      {
         float64_t got;
         float64_t exp;
         got = vgetq_lane_f64(result.val[2], 0);
         exp = 0.8388789658921323;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 2 Lane 0 ",
                      exp,
                      got);
            }
      }
      {
         float64_t got;
         float64_t exp;
         got = vgetq_lane_f64(result.val[2], 1);
         exp = 0.7292796459882699;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 2 Lane 1 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1526() {

{
   {
      poly8_t arg1[3];
      poly8x16x3_t arg2;
      poly8x16x3_t result;
      char* str1 = "ReproInfo2 {semantics = \"load3_lane\", fnname = \"vld3q_lane_p8\", rettype = \"poly8x16x3_t\", argtypes = \"[__transfersize(3) poly8_t const *,poly8x16x3_t,__constrange(0,15) int]\", vals = [PtrVal [PolyVal [0,0,0,0,0,0,1,0],PolyVal [0,0,1,0,1,1,1,1],PolyVal [1,0,0,1,1,0,0,0]],ArrayVal [VectorVal [PolyVal [0,0,1,0,1,1,1,1],PolyVal [0,0,1,1,1,1,1,1],PolyVal [1,1,1,1,1,0,1,1],PolyVal [0,0,1,0,1,0,1,1],PolyVal [0,1,0,0,0,1,0,0],PolyVal [1,0,1,1,1,1,1,1],PolyVal [0,1,0,1,0,1,1,0],PolyVal [1,1,0,1,0,0,1,1],PolyVal [1,1,1,1,0,1,0,0],PolyVal [1,1,0,1,1,1,1,0],PolyVal [0,1,0,1,1,0,1,1],PolyVal [0,0,1,1,0,1,1,1],PolyVal [1,1,0,1,1,0,0,0],PolyVal [1,1,1,0,1,0,1,1],PolyVal [1,0,1,1,0,0,0,1],PolyVal [0,0,1,1,1,1,0,0]],VectorVal [PolyVal [0,0,0,1,1,1,1,1],PolyVal [1,1,0,1,1,0,0,0],PolyVal [0,0,0,1,0,0,0,0],PolyVal [1,1,0,0,0,0,0,0],PolyVal [1,1,1,1,1,1,0,0],PolyVal [1,0,1,0,0,0,1,0],PolyVal [1,0,1,1,0,1,1,0],PolyVal [1,1,1,1,0,0,1,1],PolyVal [1,1,0,0,0,1,0,1],PolyVal [0,1,0,1,0,0,0,0],PolyVal [0,1,1,1,1,1,0,0],PolyVal [1,1,1,1,1,0,0,1],PolyVal [0,1,0,1,1,0,1,0],PolyVal [0,0,0,0,0,0,0,0],PolyVal [1,0,1,1,1,0,1,0],PolyVal [0,1,0,1,0,1,0,1]],VectorVal [PolyVal [0,1,1,0,0,0,0,0],PolyVal [0,1,0,0,0,0,0,0],PolyVal [1,1,0,1,1,1,0,0],PolyVal [1,1,1,1,1,0,0,1],PolyVal [0,0,1,1,0,0,0,0],PolyVal [0,1,0,1,1,1,0,0],PolyVal [0,1,0,1,1,1,1,1],PolyVal [0,0,1,0,1,0,0,0],PolyVal [0,1,1,1,1,0,1,1],PolyVal [1,1,1,1,1,1,0,1],PolyVal [1,1,1,1,0,1,1,0],PolyVal [0,1,1,1,0,1,0,1],PolyVal [1,1,1,0,0,1,1,0],PolyVal [1,0,0,1,0,1,0,1],PolyVal [1,1,0,1,0,1,1,0],PolyVal [1,0,0,0,0,1,1,1]]],IndexVal 6], start_saturated = False}";
      int reported = 0;
      arg1[0] = 64;
      arg1[1] = 244;
      arg1[2] = 25;
      arg2.val[0] = vcombine_p8(vcreate_p8(UINT64_C(0xcb6afd22d4dffcf4)),
                                vcreate_p8(UINT64_C(0x3c8dd71becda7b2f)));
      arg2.val[1] = vcombine_p8(vcreate_p8(UINT64_C(0xcf6d453f03081bf8)),
                                vcreate_p8(UINT64_C(0xaa5d005a9f3e0aa3)));
      arg2.val[2] = vcombine_p8(vcreate_p8(UINT64_C(0x14fa3a0c9f3b0206)),
                                vcreate_p8(UINT64_C(0xe16ba967ae6fbfde)));
      clear_neon_saturated();
      //  Expect: "result" = e16ba967ae6fbfde14193a0c9f3b0206aa5d005a9f3e0aa3cff4453f03081bf83c8dd71becda7b2fcb40fd22d4dffcf4
      result = vld3q_lane_p8(arg1, arg2, 6);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p8(result.val[0]), 0);
         exp = UINT64_C(0xcb40fd22d4dffcf4);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p8(result.val[0]), 1);
         exp = UINT64_C(0x3c8dd71becda7b2f);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p8(result.val[1]), 0);
         exp = UINT64_C(0xcff4453f03081bf8);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p8(result.val[1]), 1);
         exp = UINT64_C(0xaa5d005a9f3e0aa3);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p8(result.val[2]), 0);
         exp = UINT64_C(0x14193a0c9f3b0206);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p8(result.val[2]), 1);
         exp = UINT64_C(0xe16ba967ae6fbfde);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1527() {

{
   {
      poly16_t arg1[3];
      poly16x8x3_t arg2;
      poly16x8x3_t result;
      char* str1 = "ReproInfo2 {semantics = \"load3_lane\", fnname = \"vld3q_lane_p16\", rettype = \"poly16x8x3_t\", argtypes = \"[__transfersize(3) poly16_t const *,poly16x8x3_t,__constrange(0,7) int]\", vals = [PtrVal [PolyVal [1,1,0,1,0,0,1,1,0,0,0,1,1,0,1,1],PolyVal [1,1,0,0,1,1,1,1,0,0,1,1,1,1,1,0],PolyVal [1,1,1,1,1,0,1,1,0,1,0,0,0,0,1,1]],ArrayVal [VectorVal [PolyVal [1,1,0,0,0,1,1,0,1,0,0,0,1,0,0,1],PolyVal [0,0,1,0,1,1,1,0,1,1,1,1,1,0,0,0],PolyVal [0,0,1,1,0,1,0,1,0,1,1,0,0,1,1,0],PolyVal [0,1,0,0,0,1,0,1,0,1,1,0,1,0,0,1],PolyVal [0,0,0,1,0,1,1,1,0,0,1,1,0,0,0,0],PolyVal [1,0,1,0,1,1,1,0,0,1,0,1,1,1,0,0],PolyVal [0,1,0,0,0,1,1,0,1,1,1,0,1,0,1,1],PolyVal [0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0]],VectorVal [PolyVal [0,1,0,1,1,1,1,0,1,1,1,1,1,1,0,1],PolyVal [0,1,1,0,0,0,1,0,1,0,1,1,1,1,0,0],PolyVal [0,0,0,1,1,0,0,1,0,0,1,1,1,0,1,1],PolyVal [0,0,0,1,1,0,0,0,1,1,0,0,1,0,0,0],PolyVal [1,0,0,1,0,1,0,1,1,1,0,1,0,0,0,1],PolyVal [0,1,0,0,1,1,0,0,0,1,1,1,0,0,0,1],PolyVal [1,0,1,0,0,0,0,1,1,0,0,0,1,0,1,1],PolyVal [1,0,0,1,1,0,1,1,0,0,0,0,0,1,1,1]],VectorVal [PolyVal [1,0,1,1,0,0,1,0,1,0,1,1,1,1,1,1],PolyVal [1,1,0,0,1,1,1,0,0,0,1,1,0,1,0,1],PolyVal [1,1,0,1,0,0,0,0,0,1,0,0,1,1,0,1],PolyVal [0,0,0,0,1,0,0,1,1,1,0,1,1,0,1,1],PolyVal [1,1,1,1,0,0,0,1,1,0,1,0,1,1,1,0],PolyVal [0,1,1,0,1,0,0,1,1,0,1,1,1,0,0,1],PolyVal [1,1,0,1,1,1,1,1,0,0,0,1,0,1,0,0],PolyVal [0,0,1,0,0,0,1,1,1,1,1,0,0,0,1,0]]],IndexVal 6], start_saturated = False}";
      int reported = 0;
      arg1[0] = 55499;
      arg1[1] = 31987;
      arg1[2] = 49887;
      arg2.val[0] = vcombine_p16(vcreate_p16(UINT64_C(0x96a266ac1f749163)),
                                 vcreate_p16(UINT64_C(0x2124d7623a750ce8)));
      arg2.val[1] = vcombine_p16(vcreate_p16(UINT64_C(0x1318dc983d46bf7a)),
                                 vcreate_p16(UINT64_C(0xe0d9d1858e328ba9)));
      arg2.val[2] = vcombine_p16(vcreate_p16(UINT64_C(0xdb90b20bac73fd4d)),
                                 vcreate_p16(UINT64_C(0x47c428fb9d96758f)));
      clear_neon_saturated();
      //  Expect: "result" = 47c4c2df9d96758fdb90b20bac73fd4de0d97cf38e328ba91318dc983d46bf7a2124d8cb3a750ce896a266ac1f749163
      result = vld3q_lane_p16(arg1, arg2, 6);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p16(result.val[0]), 0);
         exp = UINT64_C(0x96a266ac1f749163);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p16(result.val[0]), 1);
         exp = UINT64_C(0x2124d8cb3a750ce8);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p16(result.val[1]), 0);
         exp = UINT64_C(0x1318dc983d46bf7a);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p16(result.val[1]), 1);
         exp = UINT64_C(0xe0d97cf38e328ba9);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p16(result.val[2]), 0);
         exp = UINT64_C(0xdb90b20bac73fd4d);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p16(result.val[2]), 1);
         exp = UINT64_C(0x47c4c2df9d96758f);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1528() {
#if __ARM_NEON_FP16_INTRINSICS

{
   {
      __fp16 arg1[3];
      float16x8x3_t arg2;
      float16x8x3_t result;
      char* str1 = "ReproInfo2 {semantics = \"load3_lane\", fnname = \"vld3q_lane_f16\", rettype = \"float16x8x3_t\", argtypes = \"[__transfersize(3) __fp16 const *,float16x8x3_t,__constrange(0,7) int]\", vals = [PtrVal [FloatVal (-0.6855010418630734),FloatVal (-6.5572582054325785),FloatVal 6.863443065639668],ArrayVal [VectorVal [FloatVal (-4.795124860781799),FloatVal 1.2805411545188115,FloatVal 0.32631930129704934,FloatVal (-7.3345636748197185),FloatVal 4.443218722806591,FloatVal 6.94669695270532,FloatVal (-5.6284163611797355),FloatVal 9.876782241719233],VectorVal [FloatVal 4.9541530784608625,FloatVal (-3.4289987502913544),FloatVal 2.9407577895719132,FloatVal 9.268989384702927,FloatVal 2.122127944839196,FloatVal 8.926958407238502,FloatVal 4.0137029996128675,FloatVal 4.2943140562173365],VectorVal [FloatVal 2.6123540643889083,FloatVal (-7.293907767646328),FloatVal 7.462258557523956,FloatVal (-9.201184079847577),FloatVal 7.768233971585051,FloatVal (-7.724597758809713),FloatVal 4.4317119969537515,FloatVal 9.419274947931239]],IndexVal 4], start_saturated = False}";
      int reported = 0;
      arg1[0] = -0.6855010418630734;
      arg1[1] = -6.5572582054325785;
      arg1[2] = 6.863443065639668;
      arg2.val[0] = vcombine_f16(vcreate_f16(UINT64_C(0xc75535383d1fc4cb)),
                                 vcreate_f16(UINT64_C(0x48f0c5a046f24471)));
      arg2.val[1] = vcombine_f16(vcreate_f16(UINT64_C(0x48a241e1c2db44f4)),
                                 vcreate_f16(UINT64_C(0x444b44034876403e)));
      arg2.val[2] = vcombine_f16(vcreate_f16(UINT64_C(0xc8994776c74b4139)),
                                 vcreate_f16(UINT64_C(0x48b5446ec7b947c4)));
      clear_neon_saturated();
      //  Expect: "result" = 48b5446ec7b946ddc8994776c74b4139444b44034876c68e48a241e1c2db44f448f0c5a046f2b97bc75535383d1fc4cb
      result = vld3q_lane_f16(arg1, arg2, 4);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[0], 0);
         exp = -4.795124860781799;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 0 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[0], 1);
         exp = 1.2805411545188115;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 1 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[0], 2);
         exp = 0.32631930129704934;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 2 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[0], 3);
         exp = -7.3345636748197185;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 3 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[0], 4);
         exp = -0.6855010418630734;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 4 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[0], 5);
         exp = 6.94669695270532;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 5 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[0], 6);
         exp = -5.6284163611797355;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 6 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[0], 7);
         exp = 9.876782241719233;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 7 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[1], 0);
         exp = 4.9541530784608625;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 0 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[1], 1);
         exp = -3.4289987502913544;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 1 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[1], 2);
         exp = 2.9407577895719132;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 2 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[1], 3);
         exp = 9.268989384702927;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 3 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[1], 4);
         exp = -6.5572582054325785;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 4 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[1], 5);
         exp = 8.926958407238502;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 5 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[1], 6);
         exp = 4.0137029996128675;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 6 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[1], 7);
         exp = 4.2943140562173365;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 7 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[2], 0);
         exp = 2.6123540643889083;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 2 Lane 0 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[2], 1);
         exp = -7.293907767646328;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 2 Lane 1 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[2], 2);
         exp = 7.462258557523956;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 2 Lane 2 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[2], 3);
         exp = -9.201184079847577;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 2 Lane 3 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[2], 4);
         exp = 6.863443065639668;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 2 Lane 4 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[2], 5);
         exp = -7.724597758809713;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 2 Lane 5 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[2], 6);
         exp = 4.4317119969537515;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 2 Lane 6 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[2], 7);
         exp = 9.419274947931239;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 2 Lane 7 ",
                      exp,
                      got);
            }
      }
   }
}
#endif
}
void dotests_1529() {

{
   {
      uint64_t arg1[3];
      uint64x2x3_t arg2;
      uint64x2x3_t result;
      char* str1 = "ReproInfo2 {semantics = \"load3_lane\", fnname = \"vld3q_lane_u64\", rettype = \"uint64x2x3_t\", argtypes = \"[__transfersize(3) uint64_t const *,uint64x2x3_t,__constrange(0,1) int]\", vals = [PtrVal [IntegerVal 9223239408264708095,IntegerVal 251231964495871,IntegerVal 18446744071562035200],ArrayVal [VectorVal [IntegerVal 18446603338288791551,IntegerVal 7215048082319161945],VectorVal [IntegerVal 9223653511831453696,IntegerVal 5391512443551770592],VectorVal [IntegerVal 12625841551038218240,IntegerVal 281474976645120]],IndexVal 1], start_saturated = False}";
      int reported = 0;
      arg1[0] = UINT64_C(0x7fff876000007fff);
      arg1[1] = UINT64_C(0x0000e47e7fffffff);
      arg1[2] = UINT64_C(0xffffffff7fff8000);
      arg2.val[0] = vcombine_u64(vcreate_u64(UINT64_C(0xffff80007b3cffff)),
                                 vcreate_u64(UINT64_C(0x64210000ffff3a59)));
      arg2.val[1] = vcombine_u64(vcreate_u64(UINT64_C(0x8000ffffffff8000)),
                                 vcreate_u64(UINT64_C(0x4ad28000800067e0)));
      arg2.val[2] = vcombine_u64(vcreate_u64(UINT64_C(0xaf37ffff00000000)),
                                 vcreate_u64(UINT64_C(0x0000ffffffff0000)));
      clear_neon_saturated();
      //  Expect: "result" = ffffffff7fff8000af37ffff000000000000e47e7fffffff8000ffffffff80007fff876000007fffffff80007b3cffff
      result = vld3q_lane_u64(arg1, arg2, 1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result.val[0], 0);
         exp = UINT64_C(0xffff80007b3cffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result.val[0], 1);
         exp = UINT64_C(0x7fff876000007fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result.val[1], 0);
         exp = UINT64_C(0x8000ffffffff8000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result.val[1], 1);
         exp = UINT64_C(0x0000e47e7fffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result.val[2], 0);
         exp = UINT64_C(0xaf37ffff00000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result.val[2], 1);
         exp = UINT64_C(0xffffffff7fff8000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1530() {

{
   {
      int64_t arg1[3];
      int64x2x3_t arg2;
      int64x2x3_t result;
      char* str1 = "ReproInfo2 {semantics = \"load3_lane\", fnname = \"vld3q_lane_s64\", rettype = \"int64x2x3_t\", argtypes = \"[__transfersize(3) int64_t const *,int64x2x3_t,__constrange(0,1) int]\", vals = [PtrVal [IntegerVal (-7071355102413455360),IntegerVal 140733193453567,IntegerVal 140734792073216],ArrayVal [VectorVal [IntegerVal (-9223231299366354945),IntegerVal 276477509926912],VectorVal [IntegerVal (-9223090561878097920),IntegerVal (-140739635865892)],VectorVal [IntegerVal 9223157297079910400,IntegerVal (-9223322769284956161)]],IndexVal 1], start_saturated = False}";
      int reported = 0;
      arg1[0] = INT64_C(-7071355102413455360);
      arg1[1] = INT64_C(140733193453567);
      arg1[2] = INT64_C(140734792073216);
      arg2.val[0] = vcombine_s64(vcreate_s64(UINT64_C(0x800080000000ffff)),
                                 vcreate_s64(UINT64_C(0x0000fb746fc48000)));
      arg2.val[1] = vcombine_s64(vcreate_s64(UINT64_C(0x8000ffffffff8000)),
                                 vcreate_s64(UINT64_C(0xffff7fff7fff96dc)));
      arg2.val[2] = vcombine_s64(vcreate_s64(UINT64_C(0x7fff3cb200000000)),
                                 vcreate_s64(UINT64_C(0x80002cceffff7fff)));
      clear_neon_saturated();
      //  Expect: "result" = 00007fff5f4a00007fff3cb20000000000007fff0000ffff8000ffffffff80009ddd800000000000800080000000ffff
      result = vld3q_lane_s64(arg1, arg2, 1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result.val[0]), 0);
         exp = UINT64_C(0x800080000000ffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result.val[0]), 1);
         exp = UINT64_C(0x9ddd800000000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result.val[1]), 0);
         exp = UINT64_C(0x8000ffffffff8000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result.val[1]), 1);
         exp = UINT64_C(0x00007fff0000ffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result.val[2]), 0);
         exp = UINT64_C(0x7fff3cb200000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result.val[2]), 1);
         exp = UINT64_C(0x00007fff5f4a0000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1531() {

{
   {
      poly64_t arg1[3];
      poly64x2x3_t arg2;
      poly64x2x3_t result;
      char* str1 = "ReproInfo2 {semantics = \"load3_lane\", fnname = \"vld3q_lane_p64\", rettype = \"poly64x2x3_t\", argtypes = \"[__transfersize(3) poly64_t const *,poly64x2x3_t,__constrange(0,1) int]\", vals = [PtrVal [PolyVal [0,1,1,1,0,1,1,1,1,0,0,1,0,0,1,1,0,1,1,1,1,0,1,0,0,1,1,1,0,1,0,0,1,1,1,0,0,0,0,0,0,1,1,0,1,1,0,1,0,1,0,0,0,1,0,1,0,0,0,1,1,0,1,0],PolyVal [0,0,0,0,0,0,1,0,1,1,1,1,0,1,1,0,1,1,1,1,1,1,0,0,1,0,0,0,0,0,1,1,1,1,0,1,1,1,1,0,1,0,0,0,1,1,0,0,0,1,1,1,0,0,1,0,0,1,1,0,1,1,1,1],PolyVal [0,1,0,1,0,1,1,0,1,1,1,1,1,0,1,1,1,0,0,1,0,0,1,0,1,1,0,1,0,1,1,0,0,1,0,1,1,0,0,1,0,0,1,0,0,0,0,1,1,1,0,1,1,1,0,1,1,1,1,1,1,1,1,1]],ArrayVal [VectorVal [PolyVal [0,1,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,0,1,0,1,1,0,0,1,0,0,1,0,0,1,0,1,0,0,0,1,1,0,1,1,1,0,1,1,1,1,1,0,1,0,0,1],PolyVal [1,1,1,1,1,1,0,1,1,1,0,0,0,0,0,0,1,0,1,0,1,0,0,1,0,1,1,1,1,0,1,0,0,0,1,1,0,0,1,1,0,0,1,0,0,1,0,1,1,1,1,0,0,1,0,0,0,0,1,0,1,0,0,1]],VectorVal [PolyVal [0,1,0,0,1,0,0,0,1,1,1,0,0,0,1,0,1,0,0,0,0,1,1,1,1,1,0,0,0,1,1,1,1,1,1,0,0,1,1,0,1,0,1,1,1,0,1,1,0,1,1,1,0,0,1,0,1,1,0,1,1,1,1,1],PolyVal [1,0,0,0,0,0,0,0,1,0,1,0,0,0,1,0,1,1,1,0,1,0,1,0,1,0,1,1,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,1,1,1,1,1,1,0,1,0,1,0,1,0,1,1,0,1,1,0,1]],VectorVal [PolyVal [0,0,1,0,1,0,1,0,1,0,1,0,1,1,0,1,0,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,1,1,0,1,0,0,1,0,0,0,0,0,1,1,1,0,1,1,0,1,1,0,0,1,1,1,0,1,1],PolyVal [0,1,1,0,1,1,1,1,1,1,0,1,1,0,1,1,0,0,0,1,0,1,0,0,1,1,0,0,1,1,1,0,0,1,1,1,0,1,1,1,0,0,1,1,0,1,1,0,1,1,0,1,1,1,1,0,1,0,0,0,1,0,0,1]]],IndexVal 1], start_saturated = False}";
      int reported = 0;
      arg1[0] = 6386867363523774958;
      arg1[1] = -698566484602949824;
      arg1[2] = -19275974633201814;
      arg2.val[0] = vcombine_p64(vcreate_p64(UINT64_C(0x97dd8a49afe01802)),
                                 vcreate_p64(UINT64_C(0x9427a4cc5e9503bf)));
      arg2.val[1] = vcombine_p64(vcreate_p64(UINT64_C(0xfb4edd67e3e14712)),
                                 vcreate_p64(UINT64_C(0xb6abf8806d574501)));
      arg2.val[2] = vcombine_p64(vcreate_p64(UINT64_C(0xdcdb82580d20b554)),
                                 vcreate_p64(UINT64_C(0x917b6cee7328dbf6)));
      clear_neon_saturated();
      //  Expect: "result" = ffbb849a6b49df6adcdb82580d20b554f64e317bc13f6f40fb4edd67e3e1471258a2b6072e5ec9ee97dd8a49afe01802
      result = vld3q_lane_p64(arg1, arg2, 1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p64(result.val[0]), 0);
         exp = UINT64_C(0x97dd8a49afe01802);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p64(result.val[0]), 1);
         exp = UINT64_C(0x58a2b6072e5ec9ee);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p64(result.val[1]), 0);
         exp = UINT64_C(0xfb4edd67e3e14712);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p64(result.val[1]), 1);
         exp = UINT64_C(0xf64e317bc13f6f40);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p64(result.val[2]), 0);
         exp = UINT64_C(0xdcdb82580d20b554);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p64(result.val[2]), 1);
         exp = UINT64_C(0xffbb849a6b49df6a);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1532() {

{
   {
      uint8_t arg1[3];
      uint8x8x3_t arg2;
      uint8x8x3_t result;
      char* str1 = "ReproInfo2 {semantics = \"load3_lane\", fnname = \"vld3_lane_u8\", rettype = \"uint8x8x3_t\", argtypes = \"[__transfersize(3) uint8_t const *,uint8x8x3_t,__constrange(0,7) int]\", vals = [PtrVal [IntegerVal 0,IntegerVal 127,IntegerVal 127],ArrayVal [VectorVal [IntegerVal 0,IntegerVal 255,IntegerVal 0,IntegerVal 255,IntegerVal 184,IntegerVal 127,IntegerVal 255,IntegerVal 9],VectorVal [IntegerVal 127,IntegerVal 0,IntegerVal 109,IntegerVal 0,IntegerVal 27,IntegerVal 255,IntegerVal 0,IntegerVal 128],VectorVal [IntegerVal 127,IntegerVal 0,IntegerVal 255,IntegerVal 128,IntegerVal 127,IntegerVal 128,IntegerVal 52,IntegerVal 152]],IndexVal 4], start_saturated = False}";
      int reported = 0;
      arg1[0] = 0;
      arg1[1] = 127U;
      arg1[2] = 127U;
      arg2.val[0] = vcreate_u8(UINT64_C(0x09ff7fb8ff00ff00));
      arg2.val[1] = vcreate_u8(UINT64_C(0x8000ff1b006d007f));
      arg2.val[2] = vcreate_u8(UINT64_C(0x9834807f80ff007f));
      clear_neon_saturated();
      //  Expect: "result" = 9834807f80ff007f8000ff7f006d007f09ff7f00ff00ff00
      result = vld3_lane_u8(arg1, arg2, 4);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_u8(result.val[0]), 0);
         exp = UINT64_C(0x09ff7f00ff00ff00);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_u8(result.val[1]), 0);
         exp = UINT64_C(0x8000ff7f006d007f);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_u8(result.val[2]), 0);
         exp = UINT64_C(0x9834807f80ff007f);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1533() {

{
   {
      uint16_t arg1[3];
      uint16x4x3_t arg2;
      uint16x4x3_t result;
      char* str1 = "ReproInfo2 {semantics = \"load3_lane\", fnname = \"vld3_lane_u16\", rettype = \"uint16x4x3_t\", argtypes = \"[__transfersize(3) uint16_t const *,uint16x4x3_t,__constrange(0,3) int]\", vals = [PtrVal [IntegerVal 32768,IntegerVal 29393,IntegerVal 32767],ArrayVal [VectorVal [IntegerVal 32768,IntegerVal 65535,IntegerVal 42237,IntegerVal 65535],VectorVal [IntegerVal 32768,IntegerVal 32768,IntegerVal 0,IntegerVal 32767],VectorVal [IntegerVal 65535,IntegerVal 0,IntegerVal 0,IntegerVal 65535]],IndexVal 2], start_saturated = False}";
      int reported = 0;
      arg1[0] = 32768U;
      arg1[1] = 29393U;
      arg1[2] = 32767U;
      arg2.val[0] = vcreate_u16(UINT64_C(0xffffa4fdffff8000));
      arg2.val[1] = vcreate_u16(UINT64_C(0x7fff000080008000));
      arg2.val[2] = vcreate_u16(UINT64_C(0xffff00000000ffff));
      clear_neon_saturated();
      //  Expect: "result" = ffff7fff0000ffff7fff72d180008000ffff8000ffff8000
      result = vld3_lane_u16(arg1, arg2, 2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_u16(result.val[0]), 0);
         exp = UINT64_C(0xffff8000ffff8000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_u16(result.val[1]), 0);
         exp = UINT64_C(0x7fff72d180008000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_u16(result.val[2]), 0);
         exp = UINT64_C(0xffff7fff0000ffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1534() {

{
   {
      uint32_t arg1[3];
      uint32x2x3_t arg2;
      uint32x2x3_t result;
      char* str1 = "ReproInfo2 {semantics = \"load3_lane\", fnname = \"vld3_lane_u32\", rettype = \"uint32x2x3_t\", argtypes = \"[__transfersize(3) uint32_t const *,uint32x2x3_t,__constrange(0,1) int]\", vals = [PtrVal [IntegerVal 4294934528,IntegerVal 2147450879,IntegerVal 4294967295],ArrayVal [VectorVal [IntegerVal 2147450880,IntegerVal 32768],VectorVal [IntegerVal 2147483648,IntegerVal 2147450880],VectorVal [IntegerVal 4294934528,IntegerVal 2147450880]],IndexVal 0], start_saturated = False}";
      int reported = 0;
      arg1[0] = 4294934528U;
      arg1[1] = 2147450879U;
      arg1[2] = 4294967295U;
      arg2.val[0] = vcreate_u32(UINT64_C(0x000080007fff8000));
      arg2.val[1] = vcreate_u32(UINT64_C(0x7fff800080000000));
      arg2.val[2] = vcreate_u32(UINT64_C(0x7fff8000ffff8000));
      clear_neon_saturated();
      //  Expect: "result" = 7fff8000ffffffff7fff80007fff7fff00008000ffff8000
      result = vld3_lane_u32(arg1, arg2, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_u32(result.val[0]), 0);
         exp = UINT64_C(0x00008000ffff8000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_u32(result.val[1]), 0);
         exp = UINT64_C(0x7fff80007fff7fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_u32(result.val[2]), 0);
         exp = UINT64_C(0x7fff8000ffffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1535() {

{
   {
      int8_t arg1[3];
      int8x8x3_t arg2;
      int8x8x3_t result;
      char* str1 = "ReproInfo2 {semantics = \"load3_lane\", fnname = \"vld3_lane_s8\", rettype = \"int8x8x3_t\", argtypes = \"[__transfersize(3) int8_t const *,int8x8x3_t,__constrange(0,7) int]\", vals = [PtrVal [IntegerVal 0,IntegerVal (-128),IntegerVal 12],ArrayVal [VectorVal [IntegerVal 0,IntegerVal (-1),IntegerVal 111,IntegerVal (-1),IntegerVal 2,IntegerVal 0,IntegerVal 0,IntegerVal (-1)],VectorVal [IntegerVal 127,IntegerVal (-1),IntegerVal (-1),IntegerVal (-128),IntegerVal 102,IntegerVal (-128),IntegerVal 70,IntegerVal 107],VectorVal [IntegerVal (-128),IntegerVal 127,IntegerVal 0,IntegerVal (-114),IntegerVal (-50),IntegerVal 0,IntegerVal (-128),IntegerVal 59]],IndexVal 7], start_saturated = False}";
      int reported = 0;
      arg1[0] = 0;
      arg1[1] = -128;
      arg1[2] = 12;
      arg2.val[0] = vcreate_s8(UINT64_C(0xff000002ff6fff00));
      arg2.val[1] = vcreate_s8(UINT64_C(0x6b46806680ffff7f));
      arg2.val[2] = vcreate_s8(UINT64_C(0x3b8000ce8e007f80));
      clear_neon_saturated();
      //  Expect: "result" = 0c8000ce8e007f808046806680ffff7f00000002ff6fff00
      result = vld3_lane_s8(arg1, arg2, 7);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_s8(result.val[0]), 0);
         exp = UINT64_C(0x00000002ff6fff00);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_s8(result.val[1]), 0);
         exp = UINT64_C(0x8046806680ffff7f);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_s8(result.val[2]), 0);
         exp = UINT64_C(0x0c8000ce8e007f80);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1536() {

{
   {
      int16_t arg1[3];
      int16x4x3_t arg2;
      int16x4x3_t result;
      char* str1 = "ReproInfo2 {semantics = \"load3_lane\", fnname = \"vld3_lane_s16\", rettype = \"int16x4x3_t\", argtypes = \"[__transfersize(3) int16_t const *,int16x4x3_t,__constrange(0,3) int]\", vals = [PtrVal [IntegerVal (-32768),IntegerVal (-1),IntegerVal 0],ArrayVal [VectorVal [IntegerVal (-9412),IntegerVal (-1),IntegerVal (-32768),IntegerVal 0],VectorVal [IntegerVal (-1),IntegerVal 0,IntegerVal 0,IntegerVal (-26337)],VectorVal [IntegerVal 32767,IntegerVal 0,IntegerVal (-13198),IntegerVal (-32768)]],IndexVal 2], start_saturated = False}";
      int reported = 0;
      arg1[0] = -32768;
      arg1[1] = -1;
      arg1[2] = 0;
      arg2.val[0] = vcreate_s16(UINT64_C(0x00008000ffffdb3c));
      arg2.val[1] = vcreate_s16(UINT64_C(0x991f00000000ffff));
      arg2.val[2] = vcreate_s16(UINT64_C(0x8000cc7200007fff));
      clear_neon_saturated();
      //  Expect: "result" = 8000000000007fff991fffff0000ffff00008000ffffdb3c
      result = vld3_lane_s16(arg1, arg2, 2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_s16(result.val[0]), 0);
         exp = UINT64_C(0x00008000ffffdb3c);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_s16(result.val[1]), 0);
         exp = UINT64_C(0x991fffff0000ffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_s16(result.val[2]), 0);
         exp = UINT64_C(0x8000000000007fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1537() {

{
   {
      int32_t arg1[3];
      int32x2x3_t arg2;
      int32x2x3_t result;
      char* str1 = "ReproInfo2 {semantics = \"load3_lane\", fnname = \"vld3_lane_s32\", rettype = \"int32x2x3_t\", argtypes = \"[__transfersize(3) int32_t const *,int32x2x3_t,__constrange(0,1) int]\", vals = [PtrVal [IntegerVal (-2147483648),IntegerVal 838008831,IntegerVal 1464888991],ArrayVal [VectorVal [IntegerVal (-2147450881),IntegerVal (-2147483648)],VectorVal [IntegerVal (-1),IntegerVal 65535],VectorVal [IntegerVal (-1914175488),IntegerVal (-1)]],IndexVal 0], start_saturated = False}";
      int reported = 0;
      arg1[0] = (int32_t) 0x80000000;
      arg1[1] = 838008831;
      arg1[2] = 1464888991;
      arg2.val[0] = vcreate_s32(UINT64_C(0x8000000080007fff));
      arg2.val[1] = vcreate_s32(UINT64_C(0x0000ffffffffffff));
      arg2.val[2] = vcreate_s32(UINT64_C(0xffffffff8de80000));
      clear_neon_saturated();
      //  Expect: "result" = ffffffff57506e9f0000ffff31f2ffff8000000080000000
      result = vld3_lane_s32(arg1, arg2, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_s32(result.val[0]), 0);
         exp = UINT64_C(0x8000000080000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_s32(result.val[1]), 0);
         exp = UINT64_C(0x0000ffff31f2ffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_s32(result.val[2]), 0);
         exp = UINT64_C(0xffffffff57506e9f);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1538() {

{
   {
      float32_t arg1[3];
      float32x2x3_t arg2;
      float32x2x3_t result;
      char* str1 = "ReproInfo2 {semantics = \"load3_lane\", fnname = \"vld3_lane_f32\", rettype = \"float32x2x3_t\", argtypes = \"[__transfersize(3) float32_t const *,float32x2x3_t,__constrange(0,1) int]\", vals = [PtrVal [FloatVal 0.41296499967575073,FloatVal 0.64239102602005,FloatVal 0.7670263051986694],ArrayVal [VectorVal [FloatVal 0.37100648880004883,FloatVal 0.11696791648864746],VectorVal [FloatVal 0.8759456276893616,FloatVal 0.26287227869033813],VectorVal [FloatVal 0.7127490043640137,FloatVal 0.524823009967804]],IndexVal 0], start_saturated = False}";
      int reported = 0;
      arg1[0] = ((float32_t) 0.41296499967575073);
      arg1[1] = ((float32_t) 0.64239102602005);
      arg1[2] = ((float32_t) 0.7670263051986694);
      arg2.val[0] = vcreate_f32(UINT64_C(0x3def8ce03ebdf490));
      arg2.val[1] = vcreate_f32(UINT64_C(0x3e8697323f603df9));
      arg2.val[2] = vcreate_f32(UINT64_C(0x3f065acd3f3676b8));
      clear_neon_saturated();
      //  Expect: "result" = 3f065acd3f445bd63e8697323f2473bd3def8ce03ed37026
      result = vld3_lane_f32(arg1, arg2, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result.val[0], 0);
         exp = ((float32_t) 0.41296499967575073);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 0 ",
                      exp,
                      got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result.val[0], 1);
         exp = ((float32_t) 0.11696791648864746);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 1 ",
                      exp,
                      got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result.val[1], 0);
         exp = ((float32_t) 0.64239102602005);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 0 ",
                      exp,
                      got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result.val[1], 1);
         exp = ((float32_t) 0.26287227869033813);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 1 ",
                      exp,
                      got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result.val[2], 0);
         exp = ((float32_t) 0.7670263051986694);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 2 Lane 0 ",
                      exp,
                      got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result.val[2], 1);
         exp = ((float32_t) 0.524823009967804);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 2 Lane 1 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1539() {

{
   {
      float64_t arg1[3];
      float64x1x3_t arg2;
      float64x1x3_t result;
      char* str1 = "ReproInfo2 {semantics = \"load3_lane\", fnname = \"vld3_lane_f64\", rettype = \"float64x1x3_t\", argtypes = \"[__transfersize(3) float64_t const *,float64x1x3_t,__constrange(0,0) int]\", vals = [PtrVal [FloatVal 0.7742404894886369,FloatVal 0.5334449810960322,FloatVal 0.13310928096691466],ArrayVal [VectorVal [FloatVal 0.2727180556857547],VectorVal [FloatVal 0.9345666044231505],VectorVal [FloatVal 0.8707272868399968]],IndexVal 0], start_saturated = False}";
      int reported = 0;
      arg1[0] = 0.7742404894886369;
      arg1[1] = 0.5334449810960322;
      arg1[2] = 0.13310928096691466;
      arg2.val[0] = vcreate_f64(UINT64_C(0x3fd174366e8cbccc));
      arg2.val[1] = vcreate_f64(UINT64_C(0x3fede7f8393dcc65));
      arg2.val[2] = vcreate_f64(UINT64_C(0x3febdcff7896cd99));
      clear_neon_saturated();
      //  Expect: "result" = 3fc109b99446033c3fe111fb3580bac03fe8c693fdb2f79f
      result = vld3_lane_f64(arg1, arg2, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float64_t got;
         float64_t exp;
         got = vget_lane_f64(result.val[0], 0);
         exp = 0.7742404894886369;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 0 ",
                      exp,
                      got);
            }
      }
      {
         float64_t got;
         float64_t exp;
         got = vget_lane_f64(result.val[1], 0);
         exp = 0.5334449810960322;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 0 ",
                      exp,
                      got);
            }
      }
      {
         float64_t got;
         float64_t exp;
         got = vget_lane_f64(result.val[2], 0);
         exp = 0.13310928096691466;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 2 Lane 0 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1540() {

{
   {
      poly8_t arg1[3];
      poly8x8x3_t arg2;
      poly8x8x3_t result;
      char* str1 = "ReproInfo2 {semantics = \"load3_lane\", fnname = \"vld3_lane_p8\", rettype = \"poly8x8x3_t\", argtypes = \"[__transfersize(3) poly8_t const *,poly8x8x3_t,__constrange(0,7) int]\", vals = [PtrVal [PolyVal [1,0,1,1,0,1,1,1],PolyVal [0,1,1,0,0,0,1,0],PolyVal [1,1,0,1,0,0,1,1]],ArrayVal [VectorVal [PolyVal [1,0,1,0,0,1,1,1],PolyVal [0,0,1,1,0,1,1,0],PolyVal [1,0,1,0,1,1,1,1],PolyVal [0,1,0,0,0,0,0,0],PolyVal [1,0,1,0,1,1,1,1],PolyVal [0,1,1,1,1,0,0,0],PolyVal [0,1,0,1,1,0,0,1],PolyVal [1,0,1,1,1,0,1,0]],VectorVal [PolyVal [0,0,0,0,0,1,1,0],PolyVal [0,0,1,0,0,1,1,0],PolyVal [1,1,1,0,1,0,1,1],PolyVal [1,0,0,0,0,0,0,1],PolyVal [0,0,1,1,0,0,1,0],PolyVal [1,1,1,0,0,1,1,1],PolyVal [0,0,0,1,1,1,1,0],PolyVal [1,1,1,0,0,1,0,1]],VectorVal [PolyVal [1,0,0,0,0,0,1,0],PolyVal [0,0,1,1,1,1,1,0],PolyVal [1,0,0,0,0,1,0,0],PolyVal [0,0,1,0,0,0,0,0],PolyVal [0,0,0,0,0,0,1,1],PolyVal [0,1,0,0,0,0,0,1],PolyVal [0,0,1,1,0,1,1,1],PolyVal [0,1,1,1,0,1,1,1]]],IndexVal 2], start_saturated = True}";
      int reported = 0;
      arg1[0] = 237;
      arg1[1] = 70;
      arg1[2] = 203;
      arg2.val[0] = vcreate_p8(UINT64_C(0x5d9a1ef502f56ce5));
      arg2.val[1] = vcreate_p8(UINT64_C(0xa778e74c81d76460));
      arg2.val[2] = vcreate_p8(UINT64_C(0xeeec82c004217c41));
      set_neon_saturated();
      //  Expect: "result" = eeec82c004cb7c41a778e74c814664605d9a1ef502ed6ce5
      result = vld3_lane_p8(arg1, arg2, 2);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_p8(result.val[0]), 0);
         exp = UINT64_C(0x5d9a1ef502ed6ce5);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_p8(result.val[1]), 0);
         exp = UINT64_C(0xa778e74c81466460);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_p8(result.val[2]), 0);
         exp = UINT64_C(0xeeec82c004cb7c41);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1541() {

{
   {
      poly16_t arg1[3];
      poly16x4x3_t arg2;
      poly16x4x3_t result;
      char* str1 = "ReproInfo2 {semantics = \"load3_lane\", fnname = \"vld3_lane_p16\", rettype = \"poly16x4x3_t\", argtypes = \"[__transfersize(3) poly16_t const *,poly16x4x3_t,__constrange(0,3) int]\", vals = [PtrVal [PolyVal [0,1,1,0,1,1,1,0,0,1,1,0,1,0,1,1],PolyVal [1,0,1,0,1,1,0,0,1,0,1,0,1,1,1,0],PolyVal [0,0,0,1,1,0,0,1,0,1,1,1,0,1,1,1]],ArrayVal [VectorVal [PolyVal [0,1,1,1,1,1,0,0,1,0,1,0,0,1,0,1],PolyVal [1,1,1,0,1,0,1,0,1,1,0,1,0,0,1,1],PolyVal [1,0,1,0,0,1,1,0,1,1,1,0,1,0,1,1],PolyVal [0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1]],VectorVal [PolyVal [1,0,0,1,1,0,1,0,0,0,1,0,0,1,1,0],PolyVal [1,1,1,1,1,0,0,0,0,0,1,1,0,1,1,1],PolyVal [0,0,0,1,0,0,0,0,1,1,1,0,1,1,1,1],PolyVal [1,1,0,0,0,0,1,0,0,1,0,0,0,1,0,1]],VectorVal [PolyVal [0,0,0,1,0,1,1,1,0,1,0,1,0,0,0,1],PolyVal [1,1,1,1,1,0,0,1,1,1,1,1,1,0,1,1],PolyVal [0,1,1,0,0,1,0,1,1,1,1,0,1,1,0,1],PolyVal [0,1,0,0,1,0,1,0,0,0,0,1,1,1,1,0]]],IndexVal 2], start_saturated = False}";
      int reported = 0;
      arg1[0] = 54902;
      arg1[1] = 30005;
      arg1[2] = 61080;
      arg2.val[0] = vcreate_p16(UINT64_C(0x8180d765cb57a53e));
      arg2.val[1] = vcreate_p16(UINT64_C(0xa243f708ec1f6459));
      arg2.val[2] = vcreate_p16(UINT64_C(0x7852b7a6df9f8ae8));
      clear_neon_saturated();
      //  Expect: "result" = 7852ee98df9f8ae8a2437535ec1f64598180d676cb57a53e
      result = vld3_lane_p16(arg1, arg2, 2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_p16(result.val[0]), 0);
         exp = UINT64_C(0x8180d676cb57a53e);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_p16(result.val[1]), 0);
         exp = UINT64_C(0xa2437535ec1f6459);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_p16(result.val[2]), 0);
         exp = UINT64_C(0x7852ee98df9f8ae8);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1542() {
#if __ARM_NEON_FP16_INTRINSICS

{
   {
      __fp16 arg1[3];
      float16x4x3_t arg2;
      float16x4x3_t result;
      char* str1 = "ReproInfo2 {semantics = \"load3_lane\", fnname = \"vld3_lane_f16\", rettype = \"float16x4x3_t\", argtypes = \"[__transfersize(3) __fp16 const *,float16x4x3_t,__constrange(0,3) int]\", vals = [PtrVal [FloatVal (-7.6816890153626405),FloatVal (-0.4431110750859162),FloatVal (-4.208723766765723)],ArrayVal [VectorVal [FloatVal (-9.318489349577474),FloatVal (-5.009169384946615),FloatVal (-1.845217085021666),FloatVal (-6.15943191165532)],VectorVal [FloatVal 8.063464880347894,FloatVal (-6.465216197496377),FloatVal 3.8003675443737635,FloatVal (-6.873370498959641)],VectorVal [FloatVal 8.401194074774384,FloatVal (-5.844336212938572),FloatVal (-4.064674792856016),FloatVal (-5.768683266507939)]],IndexVal 1], start_saturated = False}";
      int reported = 0;
      arg1[0] = -7.6816890153626405;
      arg1[1] = -0.4431110750859162;
      arg1[2] = -4.208723766765723;
      arg2.val[0] = vcreate_f16(UINT64_C(0xc628bf61c502c8a8));
      arg2.val[1] = vcreate_f16(UINT64_C(0xc6df4399c6774808));
      arg2.val[2] = vcreate_f16(UINT64_C(0xc5c4c410c5d84833));
      clear_neon_saturated();
      //  Expect: "result" = c5c4c410c4354833c6df4399b7164808c628bf61c7aec8a8
      result = vld3_lane_f16(arg1, arg2, 1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         __fp16 got;
         __fp16 exp;
         got = vget_lane_f16(result.val[0], 0);
         exp = -9.318489349577474;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 0 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vget_lane_f16(result.val[0], 1);
         exp = -7.6816890153626405;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 1 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vget_lane_f16(result.val[0], 2);
         exp = -1.845217085021666;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 2 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vget_lane_f16(result.val[0], 3);
         exp = -6.15943191165532;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 3 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vget_lane_f16(result.val[1], 0);
         exp = 8.063464880347894;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 0 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vget_lane_f16(result.val[1], 1);
         exp = -0.4431110750859162;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 1 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vget_lane_f16(result.val[1], 2);
         exp = 3.8003675443737635;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 2 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vget_lane_f16(result.val[1], 3);
         exp = -6.873370498959641;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 3 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vget_lane_f16(result.val[2], 0);
         exp = 8.401194074774384;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 2 Lane 0 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vget_lane_f16(result.val[2], 1);
         exp = -4.208723766765723;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 2 Lane 1 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vget_lane_f16(result.val[2], 2);
         exp = -4.064674792856016;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 2 Lane 2 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vget_lane_f16(result.val[2], 3);
         exp = -5.768683266507939;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 2 Lane 3 ",
                      exp,
                      got);
            }
      }
   }
}
#endif
}
void dotests_1543() {

{
   {
      uint64_t arg1[3];
      uint64x1x3_t arg2;
      uint64x1x3_t result;
      char* str1 = "ReproInfo2 {semantics = \"load3_lane\", fnname = \"vld3_lane_u64\", rettype = \"uint64x1x3_t\", argtypes = \"[__transfersize(3) uint64_t const *,uint64x1x3_t,__constrange(0,0) int]\", vals = [PtrVal [IntegerVal 65535,IntegerVal 18446603331926228992,IntegerVal 18446686400888700928],ArrayVal [VectorVal [IntegerVal 9223512776490647552],VectorVal [IntegerVal 140741783257088],VectorVal [IntegerVal 9223231301513919648]],IndexVal 0], start_saturated = False}";
      int reported = 0;
      arg1[0] = UINT64_C(0x000000000000ffff);
      arg1[1] = UINT64_C(0xffff7fff00000000);
      arg1[2] = UINT64_C(0xffffcb8c00000000);
      arg2.val[0] = vcreate_u64(UINT64_C(0x8000800080008000));
      arg2.val[1] = vcreate_u64(UINT64_C(0x00008000ffff0000));
      arg2.val[2] = vcreate_u64(UINT64_C(0x7fff800080003ca0));
      clear_neon_saturated();
      //  Expect: "result" = ffffcb8c00000000ffff7fff00000000000000000000ffff
      result = vld3_lane_u64(arg1, arg2, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(result.val[0], 0);
         exp = UINT64_C(0x000000000000ffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(result.val[1], 0);
         exp = UINT64_C(0xffff7fff00000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(result.val[2], 0);
         exp = UINT64_C(0xffffcb8c00000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1544() {

{
   {
      int64_t arg1[3];
      int64x1x3_t arg2;
      int64x1x3_t result;
      char* str1 = "ReproInfo2 {semantics = \"load3_lane\", fnname = \"vld3_lane_s64\", rettype = \"int64x1x3_t\", argtypes = \"[__transfersize(3) int64_t const *,int64x1x3_t,__constrange(0,0) int]\", vals = [PtrVal [IntegerVal (-9223145447265106558),IntegerVal 205421843283968,IntegerVal 9223231299366453248],ArrayVal [VectorVal [IntegerVal 140737488355327],VectorVal [IntegerVal 140737488388096],VectorVal [IntegerVal 9223372032559832205]],IndexVal 0], start_saturated = False}";
      int reported = 0;
      arg1[0] = INT64_C(-9223145447265106558);
      arg1[1] = INT64_C(205421843283968);
      arg1[2] = INT64_C(9223231299366453248);
      arg2.val[0] = vcreate_s64(UINT64_C(0x00007fffffffffff));
      arg2.val[1] = vcreate_s64(UINT64_C(0x0000800000008000));
      arg2.val[2] = vcreate_s64(UINT64_C(0x7fffffff00005c8d));
      clear_neon_saturated();
      //  Expect: "result" = 7fff8000000080000000bad47fff80008000ce1500008582
      result = vld3_lane_s64(arg1, arg2, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_s64(result.val[0]), 0);
         exp = UINT64_C(0x8000ce1500008582);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_s64(result.val[1]), 0);
         exp = UINT64_C(0x0000bad47fff8000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_s64(result.val[2]), 0);
         exp = UINT64_C(0x7fff800000008000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1545() {

{
   {
      poly64_t arg1[3];
      poly64x1x3_t arg2;
      poly64x1x3_t result;
      char* str1 = "ReproInfo2 {semantics = \"load3_lane\", fnname = \"vld3_lane_p64\", rettype = \"poly64x1x3_t\", argtypes = \"[__transfersize(3) poly64_t const *,poly64x1x3_t,__constrange(0,0) int]\", vals = [PtrVal [PolyVal [1,0,1,0,1,1,1,0,0,1,0,0,1,0,1,0,0,1,1,1,1,1,1,0,1,0,0,0,0,0,1,0,0,1,1,1,1,0,1,1,1,0,1,1,0,1,0,0,0,1,1,0,0,1,1,1,0,1,0,0,0,0,0,0],PolyVal [1,0,0,1,0,0,1,0,1,0,1,0,0,0,0,1,0,0,0,0,0,1,0,1,1,1,1,1,0,0,1,0,0,0,0,1,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,1,0,1,0,0,1,0,1,0,1,1],PolyVal [1,1,1,1,0,1,0,1,1,1,0,1,1,0,0,1,1,1,1,1,0,1,1,0,1,0,0,0,1,0,0,1,0,1,1,1,1,0,0,0,1,1,1,0,0,1,0,0,0,1,1,0,0,1,0,0,1,1,0,1,1,1,0,1]],ArrayVal [VectorVal [PolyVal [0,1,1,1,0,1,1,0,0,0,1,1,1,1,0,0,0,1,1,0,0,1,1,1,1,1,1,1,1,0,0,0,1,1,0,1,0,0,1,0,0,0,0,0,0,1,0,1,0,0,1,1,0,1,1,0,1,0,1,1,0,0,0,1]],VectorVal [PolyVal [0,0,1,0,1,0,1,0,1,0,1,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,1,0,1,0,1,0,0,1,1,1,0,1,1,0,0,1,1,1,0,1,1,1,1,1,0,1,0,0,0,0,0,0,1,0,0,1,0,1]],VectorVal [PolyVal [1,0,1,1,1,0,0,0,1,0,1,1,1,1,1,0,1,0,0,1,1,1,1,0,0,1,0,0,0,0,1,0,0,0,1,1,1,0,0,0,1,0,1,0,0,0,1,0,1,1,1,0,0,1,0,1,0,0,0,0,0,0,0,1]]],IndexVal 0], start_saturated = False}";
      int reported = 0;
      arg1[0] = 208904865324094069;
      arg1[1] = -3125194090734385847;
      arg1[2] = -4961234927259509841;
      arg2.val[0] = vcreate_p64(UINT64_C(0x8d6ca04b1fe63c6e));
      arg2.val[1] = vcreate_p64(UINT64_C(0xa40bee6e55052554));
      arg2.val[2] = vcreate_p64(UINT64_C(0x80a7451c42797d1d));
      clear_neon_saturated();
      //  Expect: "result" = bb26271e916f9bafd4a114884fa0854902e62dde417e5275
      result = vld3_lane_p64(arg1, arg2, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_p64(result.val[0]), 0);
         exp = UINT64_C(0x02e62dde417e5275);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_p64(result.val[1]), 0);
         exp = UINT64_C(0xd4a114884fa08549);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_p64(result.val[2]), 0);
         exp = UINT64_C(0xbb26271e916f9baf);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1546() {

{
   {
      uint8_t arg1[4];
      uint8x16x4_t arg2;
      uint8x16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"load4_lane\", fnname = \"vld4q_lane_u8\", rettype = \"uint8x16x4_t\", argtypes = \"[__transfersize(4) uint8_t const *,uint8x16x4_t,__constrange(0,15) int]\", vals = [PtrVal [IntegerVal 127,IntegerVal 128,IntegerVal 127,IntegerVal 128],ArrayVal [VectorVal [IntegerVal 144,IntegerVal 0,IntegerVal 0,IntegerVal 128,IntegerVal 255,IntegerVal 162,IntegerVal 255,IntegerVal 127,IntegerVal 0,IntegerVal 255,IntegerVal 127,IntegerVal 128,IntegerVal 0,IntegerVal 128,IntegerVal 3,IntegerVal 127],VectorVal [IntegerVal 128,IntegerVal 255,IntegerVal 128,IntegerVal 128,IntegerVal 255,IntegerVal 128,IntegerVal 127,IntegerVal 255,IntegerVal 83,IntegerVal 255,IntegerVal 140,IntegerVal 228,IntegerVal 0,IntegerVal 127,IntegerVal 128,IntegerVal 0],VectorVal [IntegerVal 128,IntegerVal 179,IntegerVal 191,IntegerVal 255,IntegerVal 255,IntegerVal 0,IntegerVal 127,IntegerVal 255,IntegerVal 93,IntegerVal 255,IntegerVal 108,IntegerVal 127,IntegerVal 128,IntegerVal 255,IntegerVal 17,IntegerVal 66],VectorVal [IntegerVal 255,IntegerVal 79,IntegerVal 255,IntegerVal 22,IntegerVal 127,IntegerVal 255,IntegerVal 127,IntegerVal 0,IntegerVal 109,IntegerVal 80,IntegerVal 0,IntegerVal 127,IntegerVal 128,IntegerVal 127,IntegerVal 127,IntegerVal 126]],IndexVal 13], start_saturated = False}";
      int reported = 0;
      arg1[0] = 127U;
      arg1[1] = 128U;
      arg1[2] = 127U;
      arg1[3] = 128U;
      arg2.val[0] = vcombine_u8(vcreate_u8(UINT64_C(0x7fffa2ff80000090)),
                                vcreate_u8(UINT64_C(0x7f038000807fff00)));
      arg2.val[1] = vcombine_u8(vcreate_u8(UINT64_C(0xff7f80ff8080ff80)),
                                vcreate_u8(UINT64_C(0x00807f00e48cff53)));
      arg2.val[2] = vcombine_u8(vcreate_u8(UINT64_C(0xff7f00ffffbfb380)),
                                vcreate_u8(UINT64_C(0x4211ff807f6cff5d)));
      arg2.val[3] = vcombine_u8(vcreate_u8(UINT64_C(0x007fff7f16ff4fff)),
                                vcreate_u8(UINT64_C(0x7e7f7f807f00506d)));
      clear_neon_saturated();
      //  Expect: "result" = 7e7f80807f00506d007fff7f16ff4fff42117f807f6cff5dff7f00ffffbfb38000808000e48cff53ff7f80ff8080ff807f037f00807fff007fffa2ff80000090
      result = vld4q_lane_u8(arg1, arg2, 13);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result.val[0]), 0);
         exp = UINT64_C(0x7fffa2ff80000090);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result.val[0]), 1);
         exp = UINT64_C(0x7f037f00807fff00);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result.val[1]), 0);
         exp = UINT64_C(0xff7f80ff8080ff80);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result.val[1]), 1);
         exp = UINT64_C(0x00808000e48cff53);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result.val[2]), 0);
         exp = UINT64_C(0xff7f00ffffbfb380);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result.val[2]), 1);
         exp = UINT64_C(0x42117f807f6cff5d);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result.val[3]), 0);
         exp = UINT64_C(0x007fff7f16ff4fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 3 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result.val[3]), 1);
         exp = UINT64_C(0x7e7f80807f00506d);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 3 High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1547() {

{
   {
      uint16_t arg1[4];
      uint16x8x4_t arg2;
      uint16x8x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"load4_lane\", fnname = \"vld4q_lane_u16\", rettype = \"uint16x8x4_t\", argtypes = \"[__transfersize(4) uint16_t const *,uint16x8x4_t,__constrange(0,7) int]\", vals = [PtrVal [IntegerVal 0,IntegerVal 65535,IntegerVal 39675,IntegerVal 0],ArrayVal [VectorVal [IntegerVal 32768,IntegerVal 65535,IntegerVal 65535,IntegerVal 0,IntegerVal 28655,IntegerVal 0,IntegerVal 0,IntegerVal 42577],VectorVal [IntegerVal 18238,IntegerVal 65535,IntegerVal 39089,IntegerVal 65535,IntegerVal 65535,IntegerVal 35617,IntegerVal 0,IntegerVal 44577],VectorVal [IntegerVal 32768,IntegerVal 32768,IntegerVal 0,IntegerVal 65535,IntegerVal 16211,IntegerVal 65535,IntegerVal 32768,IntegerVal 32768],VectorVal [IntegerVal 32768,IntegerVal 65535,IntegerVal 32768,IntegerVal 3563,IntegerVal 32768,IntegerVal 32768,IntegerVal 65535,IntegerVal 0]],IndexVal 0], start_saturated = False}";
      int reported = 0;
      arg1[0] = 0;
      arg1[1] = 65535U;
      arg1[2] = 39675U;
      arg1[3] = 0;
      arg2.val[0] = vcombine_u16(vcreate_u16(UINT64_C(0x0000ffffffff8000)),
                                 vcreate_u16(UINT64_C(0xa651000000006fef)));
      arg2.val[1] = vcombine_u16(vcreate_u16(UINT64_C(0xffff98b1ffff473e)),
                                 vcreate_u16(UINT64_C(0xae2100008b21ffff)));
      arg2.val[2] = vcombine_u16(vcreate_u16(UINT64_C(0xffff000080008000)),
                                 vcreate_u16(UINT64_C(0x80008000ffff3f53)));
      arg2.val[3] = vcombine_u16(vcreate_u16(UINT64_C(0x0deb8000ffff8000)),
                                 vcreate_u16(UINT64_C(0x0000ffff80008000)));
      clear_neon_saturated();
      //  Expect: "result" = 0000ffff800080000deb8000ffff000080008000ffff3f53ffff000080009afbae2100008b21ffffffff98b1ffffffffa651000000006fef0000ffffffff0000
      result = vld4q_lane_u16(arg1, arg2, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result.val[0]), 0);
         exp = UINT64_C(0x0000ffffffff0000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result.val[0]), 1);
         exp = UINT64_C(0xa651000000006fef);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result.val[1]), 0);
         exp = UINT64_C(0xffff98b1ffffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result.val[1]), 1);
         exp = UINT64_C(0xae2100008b21ffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result.val[2]), 0);
         exp = UINT64_C(0xffff000080009afb);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result.val[2]), 1);
         exp = UINT64_C(0x80008000ffff3f53);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result.val[3]), 0);
         exp = UINT64_C(0x0deb8000ffff0000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 3 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result.val[3]), 1);
         exp = UINT64_C(0x0000ffff80008000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 3 High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1548() {

{
   {
      uint32_t arg1[4];
      uint32x4x4_t arg2;
      uint32x4x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"load4_lane\", fnname = \"vld4q_lane_u32\", rettype = \"uint32x4x4_t\", argtypes = \"[__transfersize(4) uint32_t const *,uint32x4x4_t,__constrange(0,3) int]\", vals = [PtrVal [IntegerVal 4294967295,IntegerVal 1082621952,IntegerVal 2866741247,IntegerVal 4294934528],ArrayVal [VectorVal [IntegerVal 3382771711,IntegerVal 4294967295,IntegerVal 32767,IntegerVal 2147494947],VectorVal [IntegerVal 1028259839,IntegerVal 2147450879,IntegerVal 4294967295,IntegerVal 20339],VectorVal [IntegerVal 4294934528,IntegerVal 1991802880,IntegerVal 728268799,IntegerVal 2147450880],VectorVal [IntegerVal 2147450880,IntegerVal 0,IntegerVal 2147418112,IntegerVal 4294901760]],IndexVal 1], start_saturated = False}";
      int reported = 0;
      arg1[0] = 4294967295U;
      arg1[1] = 1082621952U;
      arg1[2] = 2866741247U;
      arg1[3] = 4294934528U;
      arg2.val[0] = vcombine_u32(vcreate_u32(UINT64_C(0xffffffffc9a0ffff)),
                                 vcreate_u32(UINT64_C(0x80002c2300007fff)));
      arg2.val[1] = vcombine_u32(vcreate_u32(UINT64_C(0x7fff7fff3d49ffff)),
                                 vcreate_u32(UINT64_C(0x00004f73ffffffff)));
      arg2.val[2] = vcombine_u32(vcreate_u32(UINT64_C(0x76b88000ffff8000)),
                                 vcreate_u32(UINT64_C(0x7fff80002b687fff)));
      arg2.val[3] = vcombine_u32(vcreate_u32(UINT64_C(0x000000007fff8000)),
                                 vcreate_u32(UINT64_C(0xffff00007fff0000)));
      clear_neon_saturated();
      //  Expect: "result" = ffff00007fff0000ffff80007fff80007fff80002b687fffaadeffffffff800000004f73ffffffff408780003d49ffff80002c2300007fffffffffffc9a0ffff
      result = vld4q_lane_u32(arg1, arg2, 1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result.val[0]), 0);
         exp = UINT64_C(0xffffffffc9a0ffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result.val[0]), 1);
         exp = UINT64_C(0x80002c2300007fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result.val[1]), 0);
         exp = UINT64_C(0x408780003d49ffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result.val[1]), 1);
         exp = UINT64_C(0x00004f73ffffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result.val[2]), 0);
         exp = UINT64_C(0xaadeffffffff8000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result.val[2]), 1);
         exp = UINT64_C(0x7fff80002b687fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result.val[3]), 0);
         exp = UINT64_C(0xffff80007fff8000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 3 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result.val[3]), 1);
         exp = UINT64_C(0xffff00007fff0000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 3 High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1549() {

{
   {
      int8_t arg1[4];
      int8x16x4_t arg2;
      int8x16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"load4_lane\", fnname = \"vld4q_lane_s8\", rettype = \"int8x16x4_t\", argtypes = \"[__transfersize(4) int8_t const *,int8x16x4_t,__constrange(0,15) int]\", vals = [PtrVal [IntegerVal (-1),IntegerVal (-1),IntegerVal (-1),IntegerVal 127],ArrayVal [VectorVal [IntegerVal (-1),IntegerVal (-128),IntegerVal 0,IntegerVal (-128),IntegerVal (-128),IntegerVal 127,IntegerVal 0,IntegerVal 127,IntegerVal (-128),IntegerVal 0,IntegerVal (-57),IntegerVal 127,IntegerVal 127,IntegerVal 127,IntegerVal 127,IntegerVal 0],VectorVal [IntegerVal 127,IntegerVal (-128),IntegerVal 0,IntegerVal 0,IntegerVal 0,IntegerVal 0,IntegerVal (-37),IntegerVal 0,IntegerVal 127,IntegerVal 0,IntegerVal (-1),IntegerVal 127,IntegerVal (-128),IntegerVal 127,IntegerVal (-128),IntegerVal (-1)],VectorVal [IntegerVal (-1),IntegerVal 127,IntegerVal (-128),IntegerVal 127,IntegerVal (-128),IntegerVal 127,IntegerVal (-21),IntegerVal (-1),IntegerVal (-128),IntegerVal 127,IntegerVal 0,IntegerVal (-1),IntegerVal 83,IntegerVal (-128),IntegerVal (-1),IntegerVal 127],VectorVal [IntegerVal 127,IntegerVal (-128),IntegerVal 0,IntegerVal (-1),IntegerVal (-128),IntegerVal (-1),IntegerVal 127,IntegerVal 127,IntegerVal 0,IntegerVal (-128),IntegerVal 0,IntegerVal (-128),IntegerVal 0,IntegerVal 127,IntegerVal (-100),IntegerVal 0]],IndexVal 15], start_saturated = False}";
      int reported = 0;
      arg1[0] = -1;
      arg1[1] = -1;
      arg1[2] = -1;
      arg1[3] = 127;
      arg2.val[0] = vcombine_s8(vcreate_s8(UINT64_C(0x7f007f80800080ff)),
                                vcreate_s8(UINT64_C(0x007f7f7f7fc70080)));
      arg2.val[1] = vcombine_s8(vcreate_s8(UINT64_C(0x00db00000000807f)),
                                vcreate_s8(UINT64_C(0xff807f807fff007f)));
      arg2.val[2] = vcombine_s8(vcreate_s8(UINT64_C(0xffeb7f807f807fff)),
                                vcreate_s8(UINT64_C(0x7fff8053ff007f80)));
      arg2.val[3] = vcombine_s8(vcreate_s8(UINT64_C(0x7f7fff80ff00807f)),
                                vcreate_s8(UINT64_C(0x009c7f0080008000)));
      clear_neon_saturated();
      //  Expect: "result" = 7f9c7f00800080007f7fff80ff00807fffff8053ff007f80ffeb7f807f807fffff807f807fff007f00db00000000807fff7f7f7f7fc700807f007f80800080ff
      result = vld4q_lane_s8(arg1, arg2, 15);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result.val[0]), 0);
         exp = UINT64_C(0x7f007f80800080ff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result.val[0]), 1);
         exp = UINT64_C(0xff7f7f7f7fc70080);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result.val[1]), 0);
         exp = UINT64_C(0x00db00000000807f);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result.val[1]), 1);
         exp = UINT64_C(0xff807f807fff007f);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result.val[2]), 0);
         exp = UINT64_C(0xffeb7f807f807fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result.val[2]), 1);
         exp = UINT64_C(0xffff8053ff007f80);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result.val[3]), 0);
         exp = UINT64_C(0x7f7fff80ff00807f);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 3 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result.val[3]), 1);
         exp = UINT64_C(0x7f9c7f0080008000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 3 High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1550() {

{
   {
      int16_t arg1[4];
      int16x8x4_t arg2;
      int16x8x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"load4_lane\", fnname = \"vld4q_lane_s16\", rettype = \"int16x8x4_t\", argtypes = \"[__transfersize(4) int16_t const *,int16x8x4_t,__constrange(0,7) int]\", vals = [PtrVal [IntegerVal 0,IntegerVal (-20662),IntegerVal (-1),IntegerVal 0],ArrayVal [VectorVal [IntegerVal 0,IntegerVal (-1),IntegerVal (-32768),IntegerVal 0,IntegerVal 28693,IntegerVal (-1),IntegerVal (-32768),IntegerVal (-32768)],VectorVal [IntegerVal 0,IntegerVal 32767,IntegerVal (-1),IntegerVal (-1),IntegerVal (-1),IntegerVal 32767,IntegerVal (-1),IntegerVal 32767],VectorVal [IntegerVal (-1),IntegerVal (-1),IntegerVal 32767,IntegerVal 17584,IntegerVal 32767,IntegerVal 32767,IntegerVal (-32768),IntegerVal (-32768)],VectorVal [IntegerVal (-1),IntegerVal (-12913),IntegerVal 0,IntegerVal (-1),IntegerVal (-32768),IntegerVal 0,IntegerVal 32767,IntegerVal 13452]],IndexVal 3], start_saturated = False}";
      int reported = 0;
      arg1[0] = 0;
      arg1[1] = -20662;
      arg1[2] = -1;
      arg1[3] = 0;
      arg2.val[0] = vcombine_s16(vcreate_s16(UINT64_C(0x00008000ffff0000)),
                                 vcreate_s16(UINT64_C(0x80008000ffff7015)));
      arg2.val[1] = vcombine_s16(vcreate_s16(UINT64_C(0xffffffff7fff0000)),
                                 vcreate_s16(UINT64_C(0x7fffffff7fffffff)));
      arg2.val[2] = vcombine_s16(vcreate_s16(UINT64_C(0x44b07fffffffffff)),
                                 vcreate_s16(UINT64_C(0x800080007fff7fff)));
      arg2.val[3] = vcombine_s16(vcreate_s16(UINT64_C(0xffff0000cd8fffff)),
                                 vcreate_s16(UINT64_C(0x348c7fff00008000)));
      clear_neon_saturated();
      //  Expect: "result" = 348c7fff0000800000000000cd8fffff800080007fff7fffffff7fffffffffff7fffffff7fffffffaf4affff7fff000080008000ffff701500008000ffff0000
      result = vld4q_lane_s16(arg1, arg2, 3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result.val[0]), 0);
         exp = UINT64_C(0x00008000ffff0000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result.val[0]), 1);
         exp = UINT64_C(0x80008000ffff7015);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result.val[1]), 0);
         exp = UINT64_C(0xaf4affff7fff0000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result.val[1]), 1);
         exp = UINT64_C(0x7fffffff7fffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result.val[2]), 0);
         exp = UINT64_C(0xffff7fffffffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result.val[2]), 1);
         exp = UINT64_C(0x800080007fff7fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result.val[3]), 0);
         exp = UINT64_C(0x00000000cd8fffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 3 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result.val[3]), 1);
         exp = UINT64_C(0x348c7fff00008000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 3 High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1551() {

{
   {
      int32_t arg1[4];
      int32x4x4_t arg2;
      int32x4x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"load4_lane\", fnname = \"vld4q_lane_s32\", rettype = \"int32x4x4_t\", argtypes = \"[__transfersize(4) int32_t const *,int32x4x4_t,__constrange(0,3) int]\", vals = [PtrVal [IntegerVal 30119,IntegerVal (-597983233),IntegerVal (-2147427792),IntegerVal (-2147418113)],ArrayVal [VectorVal [IntegerVal 0,IntegerVal 0,IntegerVal (-2147450880),IntegerVal (-1016627201)],VectorVal [IntegerVal 0,IntegerVal (-2147418113),IntegerVal (-32768),IntegerVal 12874],VectorVal [IntegerVal 2147418112,IntegerVal 1544191999,IntegerVal (-32769),IntegerVal 0],VectorVal [IntegerVal 2147450879,IntegerVal (-32769),IntegerVal (-1981251584),IntegerVal (-2147426928)]],IndexVal 1], start_saturated = False}";
      int reported = 0;
      arg1[0] = 30119;
      arg1[1] = -597983233;
      arg1[2] = -2147427792;
      arg1[3] = -2147418113;
      arg2.val[0] = vcombine_s32(vcreate_s32(0),
                                 vcreate_s32(UINT64_C(0xc3677fff80008000)));
      arg2.val[1] = vcombine_s32(vcreate_s32(UINT64_C(0x8000ffff00000000)),
                                 vcreate_s32(UINT64_C(0x0000324affff8000)));
      arg2.val[2] = vcombine_s32(vcreate_s32(UINT64_C(0x5c0a7fff7fff0000)),
                                 vcreate_s32(UINT64_C(0x00000000ffff7fff)));
      arg2.val[3] = vcombine_s32(vcreate_s32(UINT64_C(0xffff7fff7fff7fff)),
                                 vcreate_s32(UINT64_C(0x8000dd9089e88000)));
      clear_neon_saturated();
      //  Expect: "result" = 8000dd9089e880008000ffff7fff7fff00000000ffff7fff8000da307fff00000000324affff8000dc5b7fff00000000c3677fff80008000000075a700000000
      result = vld4q_lane_s32(arg1, arg2, 1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result.val[0]), 0);
         exp = UINT64_C(0x000075a700000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result.val[0]), 1);
         exp = UINT64_C(0xc3677fff80008000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result.val[1]), 0);
         exp = UINT64_C(0xdc5b7fff00000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result.val[1]), 1);
         exp = UINT64_C(0x0000324affff8000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result.val[2]), 0);
         exp = UINT64_C(0x8000da307fff0000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result.val[2]), 1);
         exp = UINT64_C(0x00000000ffff7fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result.val[3]), 0);
         exp = UINT64_C(0x8000ffff7fff7fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 3 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result.val[3]), 1);
         exp = UINT64_C(0x8000dd9089e88000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 3 High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1552() {

{
   {
      float32_t arg1[4];
      float32x4x4_t arg2;
      float32x4x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"load4_lane\", fnname = \"vld4q_lane_f32\", rettype = \"float32x4x4_t\", argtypes = \"[__transfersize(4) float32_t const *,float32x4x4_t,__constrange(0,3) int]\", vals = [PtrVal [FloatVal 0.3952747583389282,FloatVal 0.9519237279891968,FloatVal 0.6438302993774414,FloatVal 0.13407719135284424],ArrayVal [VectorVal [FloatVal 0.171655535697937,FloatVal 0.20208168029785156,FloatVal 0.47090214490890503,FloatVal 0.7946769595146179],VectorVal [FloatVal 8.28903317451477e-2,FloatVal 0.5934359431266785,FloatVal 0.6081798076629639,FloatVal 0.244672954082489],VectorVal [FloatVal 0.5743256211280823,FloatVal 0.416309118270874,FloatVal 0.7470105886459351,FloatVal 0.6602539420127869],VectorVal [FloatVal 6.166797876358032e-2,FloatVal 0.16309881210327148,FloatVal 0.5257065892219543,FloatVal 0.5493727326393127]],IndexVal 2], start_saturated = False}";
      int reported = 0;
      arg1[0] = ((float32_t) 0.3952747583389282);
      arg1[1] = ((float32_t) 0.9519237279891968);
      arg1[2] = ((float32_t) 0.6438302993774414);
      arg1[3] = ((float32_t) 0.13407719135284424);
      arg2.val[0] = vcombine_f32(vcreate_f32(UINT64_C(0x3e4eee803e2fc678)),
                                 vcreate_f32(UINT64_C(0x3f4b6ff33ef11a16)));
      arg2.val[1] = vcombine_f32(vcreate_f32(UINT64_C(0x3f17eb6b3da9c268)),
                                 vcreate_f32(UINT64_C(0x3e7a8b8c3f1bb1ac)));
      arg2.val[2] = vcombine_f32(vcreate_f32(UINT64_C(0x3ed526783f130701)),
                                 vcreate_f32(UINT64_C(0x3f2906673f3f3c16)));
      arg2.val[3] = vcombine_f32(vcreate_f32(UINT64_C(0x3e2703603d7c9790)),
                                 vcreate_f32(UINT64_C(0x3f0ca3b13f0694b5)));
      clear_neon_saturated();
      //  Expect: "result" = 3f0ca3b13e094b883e2703603d7c97903f2906673f24d2103ed526783f1307013e7a8b8c3f73b1463f17eb6b3da9c2683f4b6ff33eca61743e4eee803e2fc678
      result = vld4q_lane_f32(arg1, arg2, 2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result.val[0], 0);
         exp = ((float32_t) 0.171655535697937);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 0 ",
                      exp,
                      got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result.val[0], 1);
         exp = ((float32_t) 0.20208168029785156);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 1 ",
                      exp,
                      got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result.val[0], 2);
         exp = ((float32_t) 0.3952747583389282);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 2 ",
                      exp,
                      got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result.val[0], 3);
         exp = ((float32_t) 0.7946769595146179);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 3 ",
                      exp,
                      got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result.val[1], 0);
         exp = ((float32_t) 8.28903317451477e-2);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 0 ",
                      exp,
                      got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result.val[1], 1);
         exp = ((float32_t) 0.5934359431266785);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 1 ",
                      exp,
                      got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result.val[1], 2);
         exp = ((float32_t) 0.9519237279891968);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 2 ",
                      exp,
                      got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result.val[1], 3);
         exp = ((float32_t) 0.244672954082489);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 3 ",
                      exp,
                      got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result.val[2], 0);
         exp = ((float32_t) 0.5743256211280823);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 2 Lane 0 ",
                      exp,
                      got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result.val[2], 1);
         exp = ((float32_t) 0.416309118270874);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 2 Lane 1 ",
                      exp,
                      got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result.val[2], 2);
         exp = ((float32_t) 0.6438302993774414);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 2 Lane 2 ",
                      exp,
                      got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result.val[2], 3);
         exp = ((float32_t) 0.6602539420127869);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 2 Lane 3 ",
                      exp,
                      got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result.val[3], 0);
         exp = ((float32_t) 6.166797876358032e-2);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 3 Lane 0 ",
                      exp,
                      got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result.val[3], 1);
         exp = ((float32_t) 0.16309881210327148);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 3 Lane 1 ",
                      exp,
                      got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result.val[3], 2);
         exp = ((float32_t) 0.13407719135284424);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 3 Lane 2 ",
                      exp,
                      got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result.val[3], 3);
         exp = ((float32_t) 0.5493727326393127);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 3 Lane 3 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1553() {

{
   {
      float64_t arg1[4];
      float64x2x4_t arg2;
      float64x2x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"load4_lane\", fnname = \"vld4q_lane_f64\", rettype = \"float64x2x4_t\", argtypes = \"[__transfersize(4) float64_t const *,float64x2x4_t,__constrange(0,1) int]\", vals = [PtrVal [FloatVal 0.3024869779434618,FloatVal 9.007456264666991e-2,FloatVal 0.5709021151584208,FloatVal 0.7787642573107919],ArrayVal [VectorVal [FloatVal 5.2233158529366164e-2,FloatVal 0.572618901856168],VectorVal [FloatVal 0.7951083692222324,FloatVal 0.5905698498388868],VectorVal [FloatVal 0.5652501960206823,FloatVal 0.18990311460519682],VectorVal [FloatVal 1.61146034755415e-2,FloatVal 0.9750035684043389]],IndexVal 0], start_saturated = False}";
      int reported = 0;
      arg1[0] = 0.3024869779434618;
      arg1[1] = 9.007456264666991e-2;
      arg1[2] = 0.5709021151584208;
      arg1[3] = 0.7787642573107919;
      arg2.val[0] = vcombine_f64(vcreate_f64(UINT64_C(0x3faabe4df74d02b0)),
                                 vcreate_f64(UINT64_C(0x3fe252e4e01165ca)));
      arg2.val[1] = vcombine_f64(vcreate_f64(UINT64_C(0x3fe971871b52bb71)),
                                 vcreate_f64(UINT64_C(0x3fe2e5f2bde1f909)));
      arg2.val[2] = vcombine_f64(vcreate_f64(UINT64_C(0x3fe21687943eece9)),
                                 vcreate_f64(UINT64_C(0x3fc84ebec951a568)));
      arg2.val[3] = vcombine_f64(vcreate_f64(UINT64_C(0x3f908058bba96e00)),
                                 vcreate_f64(UINT64_C(0x3fef333aaef8f539)));
      clear_neon_saturated();
      //  Expect: "result" = 3fef333aaef8f5393fe8eba3050e31cf3fc84ebec951a5683fe244d4833a53183fe2e5f2bde1f9093fb70f2064c4d9f03fe252e4e01165ca3fd35bf2576eea28
      result = vld4q_lane_f64(arg1, arg2, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float64_t got;
         float64_t exp;
         got = vgetq_lane_f64(result.val[0], 0);
         exp = 0.3024869779434618;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 0 ",
                      exp,
                      got);
            }
      }
      {
         float64_t got;
         float64_t exp;
         got = vgetq_lane_f64(result.val[0], 1);
         exp = 0.572618901856168;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 1 ",
                      exp,
                      got);
            }
      }
      {
         float64_t got;
         float64_t exp;
         got = vgetq_lane_f64(result.val[1], 0);
         exp = 9.007456264666991e-2;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 0 ",
                      exp,
                      got);
            }
      }
      {
         float64_t got;
         float64_t exp;
         got = vgetq_lane_f64(result.val[1], 1);
         exp = 0.5905698498388868;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 1 ",
                      exp,
                      got);
            }
      }
      {
         float64_t got;
         float64_t exp;
         got = vgetq_lane_f64(result.val[2], 0);
         exp = 0.5709021151584208;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 2 Lane 0 ",
                      exp,
                      got);
            }
      }
      {
         float64_t got;
         float64_t exp;
         got = vgetq_lane_f64(result.val[2], 1);
         exp = 0.18990311460519682;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 2 Lane 1 ",
                      exp,
                      got);
            }
      }
      {
         float64_t got;
         float64_t exp;
         got = vgetq_lane_f64(result.val[3], 0);
         exp = 0.7787642573107919;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 3 Lane 0 ",
                      exp,
                      got);
            }
      }
      {
         float64_t got;
         float64_t exp;
         got = vgetq_lane_f64(result.val[3], 1);
         exp = 0.9750035684043389;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 3 Lane 1 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1554() {

{
   {
      poly8_t arg1[4];
      poly8x16x4_t arg2;
      poly8x16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"load4_lane\", fnname = \"vld4q_lane_p8\", rettype = \"poly8x16x4_t\", argtypes = \"[__transfersize(4) poly8_t const *,poly8x16x4_t,__constrange(0,15) int]\", vals = [PtrVal [PolyVal [1,0,1,1,0,1,0,0],PolyVal [0,1,0,0,0,0,1,0],PolyVal [1,0,1,0,1,0,1,0],PolyVal [0,1,0,0,1,0,1,1]],ArrayVal [VectorVal [PolyVal [0,0,0,1,0,1,0,0],PolyVal [0,0,0,1,1,0,0,0],PolyVal [1,1,0,1,0,1,1,0],PolyVal [0,1,0,1,0,0,0,1],PolyVal [1,0,1,1,0,1,0,1],PolyVal [1,0,0,1,1,1,0,1],PolyVal [1,0,0,1,1,1,1,0],PolyVal [1,0,0,0,0,1,1,0],PolyVal [1,1,1,0,1,1,0,0],PolyVal [0,1,0,1,0,0,0,0],PolyVal [0,0,1,0,1,0,1,0],PolyVal [1,1,0,0,1,1,0,1],PolyVal [1,0,1,1,1,1,1,0],PolyVal [1,1,0,0,0,1,1,0],PolyVal [1,1,0,0,0,1,1,1],PolyVal [0,0,1,0,1,0,1,1]],VectorVal [PolyVal [0,0,1,1,1,0,0,1],PolyVal [1,0,0,1,1,0,0,0],PolyVal [1,0,1,0,1,1,1,1],PolyVal [0,0,0,0,1,1,0,0],PolyVal [1,1,0,0,0,0,1,1],PolyVal [0,1,0,1,1,1,1,0],PolyVal [0,1,0,0,0,0,1,1],PolyVal [1,0,0,0,0,1,0,1],PolyVal [1,0,1,0,0,0,0,0],PolyVal [1,0,0,0,1,0,0,0],PolyVal [1,0,0,0,0,0,1,0],PolyVal [0,0,1,0,1,1,1,0],PolyVal [1,1,1,1,1,1,1,1],PolyVal [1,1,0,1,0,0,1,1],PolyVal [0,0,0,1,0,0,0,0],PolyVal [0,1,0,1,1,0,0,0]],VectorVal [PolyVal [1,0,0,1,1,1,1,1],PolyVal [0,0,1,0,0,0,0,1],PolyVal [0,1,0,0,1,1,0,1],PolyVal [1,1,0,0,1,0,1,1],PolyVal [0,0,0,0,0,0,1,1],PolyVal [1,1,1,0,0,1,0,0],PolyVal [0,1,0,1,0,0,1,0],PolyVal [1,1,1,0,1,0,1,1],PolyVal [1,0,1,0,1,0,1,1],PolyVal [0,1,1,1,1,0,0,0],PolyVal [1,1,1,0,1,0,0,1],PolyVal [0,0,1,0,1,1,1,0],PolyVal [0,0,0,0,0,1,0,0],PolyVal [1,1,1,1,1,0,1,1],PolyVal [0,1,1,0,0,0,0,1],PolyVal [1,1,1,1,1,0,0,0]],VectorVal [PolyVal [0,0,1,0,1,1,0,1],PolyVal [0,0,0,1,0,0,1,0],PolyVal [0,1,1,1,1,1,0,0],PolyVal [1,1,1,1,0,0,0,1],PolyVal [1,0,1,0,1,1,1,1],PolyVal [0,0,0,1,0,0,1,0],PolyVal [1,1,0,0,1,1,0,0],PolyVal [1,1,1,1,0,1,1,1],PolyVal [0,0,1,1,0,1,1,0],PolyVal [1,1,1,1,1,1,0,0],PolyVal [0,0,1,0,0,1,0,0],PolyVal [1,0,0,0,1,0,0,1],PolyVal [1,1,0,0,1,0,0,0],PolyVal [0,1,0,1,1,1,0,1],PolyVal [0,1,1,0,0,0,0,0],PolyVal [1,1,1,0,0,1,1,1]]],IndexVal 13], start_saturated = False}";
      int reported = 0;
      arg1[0] = 45;
      arg1[1] = 66;
      arg1[2] = 85;
      arg1[3] = 210;
      arg2.val[0] = vcombine_p8(vcreate_p8(UINT64_C(0x6179b9ad8a6b1828)),
                                vcreate_p8(UINT64_C(0xd4e3637db3540a37)));
      arg2.val[1] = vcombine_p8(vcreate_p8(UINT64_C(0xa1c27ac330f5199c)),
                                vcreate_p8(UINT64_C(0x1a08cbff74411105)));
      arg2.val[2] = vcombine_p8(vcreate_p8(UINT64_C(0xd74a27c0d3b284f9)),
                                vcreate_p8(UINT64_C(0x1f86df2074971ed5)));
      arg2.val[3] = vcombine_p8(vcreate_p8(UINT64_C(0xef3348f58f3e48b4)),
                                vcreate_p8(UINT64_C(0xe706ba1391243f6c)));
      clear_neon_saturated();
      //  Expect: "result" = e706d21391243f6cef3348f58f3e48b41f86552074971ed5d74a27c0d3b284f91a0842ff74411105a1c27ac330f5199cd4e32d7db3540a376179b9ad8a6b1828
      result = vld4q_lane_p8(arg1, arg2, 13);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p8(result.val[0]), 0);
         exp = UINT64_C(0x6179b9ad8a6b1828);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p8(result.val[0]), 1);
         exp = UINT64_C(0xd4e32d7db3540a37);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p8(result.val[1]), 0);
         exp = UINT64_C(0xa1c27ac330f5199c);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p8(result.val[1]), 1);
         exp = UINT64_C(0x1a0842ff74411105);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p8(result.val[2]), 0);
         exp = UINT64_C(0xd74a27c0d3b284f9);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p8(result.val[2]), 1);
         exp = UINT64_C(0x1f86552074971ed5);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p8(result.val[3]), 0);
         exp = UINT64_C(0xef3348f58f3e48b4);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 3 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p8(result.val[3]), 1);
         exp = UINT64_C(0xe706d21391243f6c);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 3 High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1555() {

{
   {
      poly16_t arg1[4];
      poly16x8x4_t arg2;
      poly16x8x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"load4_lane\", fnname = \"vld4q_lane_p16\", rettype = \"poly16x8x4_t\", argtypes = \"[__transfersize(4) poly16_t const *,poly16x8x4_t,__constrange(0,7) int]\", vals = [PtrVal [PolyVal [1,0,0,1,0,0,1,1,0,0,1,0,1,0,0,1],PolyVal [1,0,0,1,0,0,1,1,0,1,0,1,1,0,0,0],PolyVal [1,0,0,0,0,1,1,0,1,1,0,0,0,0,1,1],PolyVal [0,0,1,0,1,0,1,1,1,1,0,1,1,0,0,1]],ArrayVal [VectorVal [PolyVal [1,1,0,1,1,1,0,1,1,1,0,1,1,1,1,0],PolyVal [0,0,1,0,0,0,0,1,0,1,0,1,1,1,0,0],PolyVal [1,0,0,1,1,0,1,1,1,0,1,0,0,0,0,0],PolyVal [1,1,0,0,1,0,1,0,1,0,0,1,1,1,0,1],PolyVal [1,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0],PolyVal [0,0,0,1,1,1,0,0,0,1,1,1,0,0,0,0],PolyVal [0,1,0,0,0,0,0,1,1,1,0,0,1,1,0,0],PolyVal [1,0,1,1,1,1,1,0,0,0,1,1,1,0,0,0]],VectorVal [PolyVal [1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0],PolyVal [0,1,0,1,1,1,1,0,1,1,0,0,0,0,1,1],PolyVal [1,0,1,0,0,0,1,1,1,0,1,1,1,1,1,0],PolyVal [0,1,0,0,1,1,0,1,0,0,1,0,0,0,1,1],PolyVal [1,1,0,1,1,0,1,0,1,0,1,1,0,1,0,0],PolyVal [1,1,1,0,1,0,1,0,0,1,1,0,0,0,0,1],PolyVal [1,0,1,0,1,1,0,1,1,1,1,0,0,1,0,0],PolyVal [1,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0]],VectorVal [PolyVal [0,0,1,1,1,0,1,0,1,0,0,0,0,0,1,0],PolyVal [1,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0],PolyVal [1,0,1,1,1,1,0,1,0,0,1,0,1,1,0,1],PolyVal [0,0,0,1,0,0,0,1,1,0,0,1,0,1,0,1],PolyVal [0,1,1,0,1,0,0,0,0,1,1,0,1,1,1,1],PolyVal [0,1,0,1,0,1,0,0,0,1,1,0,1,0,1,1],PolyVal [1,0,1,1,1,1,0,0,0,0,0,1,1,1,1,1],PolyVal [0,0,1,1,1,1,0,1,1,0,0,0,1,1,1,0]],VectorVal [PolyVal [1,1,0,1,1,0,0,1,0,1,0,0,0,0,0,1],PolyVal [0,1,0,1,1,1,1,1,1,0,0,0,0,1,1,0],PolyVal [1,0,0,0,1,0,1,1,0,0,0,1,1,0,0,1],PolyVal [0,0,0,0,0,0,0,0,1,0,0,0,1,1,0,0],PolyVal [0,0,0,0,1,1,0,1,1,0,0,1,0,0,1,0],PolyVal [1,1,1,1,1,0,0,1,0,0,1,1,1,1,1,0],PolyVal [0,0,1,1,1,0,1,1,1,1,0,1,0,1,0,0],PolyVal [1,1,0,1,1,0,0,0,0,0,0,1,1,1,1,1]]],IndexVal 0], start_saturated = False}";
      int reported = 0;
      arg1[0] = 38089;
      arg1[1] = 6857;
      arg1[2] = 50017;
      arg1[3] = 39892;
      arg2.val[0] = vcombine_p16(vcreate_p16(UINT64_C(0xb95305d93a847bbb)),
                                 vcreate_p16(UINT64_C(0x1c7d33820e381209)));
      arg2.val[1] = vcombine_p16(vcreate_p16(UINT64_C(0xc4b27dc5c37a0041)),
                                 vcreate_p16(UINT64_C(0x0c0327b586572d5b)));
      arg2.val[2] = vcombine_p16(vcreate_p16(UINT64_C(0xa988b4bd1421415c)),
                                 vcreate_p16(UINT64_C(0x71bcf83dd62af616)));
      arg2.val[3] = vcombine_p16(vcreate_p16(UINT64_C(0x310098d161fa829b)),
                                 vcreate_p16(UINT64_C(0xf81b2bdc7c9f49b0)));
      clear_neon_saturated();
      //  Expect: "result" = f81b2bdc7c9f49b0310098d161fa9bd471bcf83dd62af616a988b4bd1421c3610c0327b586572d5bc4b27dc5c37a1ac91c7d33820e381209b95305d93a8494c9
      result = vld4q_lane_p16(arg1, arg2, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p16(result.val[0]), 0);
         exp = UINT64_C(0xb95305d93a8494c9);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p16(result.val[0]), 1);
         exp = UINT64_C(0x1c7d33820e381209);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p16(result.val[1]), 0);
         exp = UINT64_C(0xc4b27dc5c37a1ac9);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p16(result.val[1]), 1);
         exp = UINT64_C(0x0c0327b586572d5b);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p16(result.val[2]), 0);
         exp = UINT64_C(0xa988b4bd1421c361);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p16(result.val[2]), 1);
         exp = UINT64_C(0x71bcf83dd62af616);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p16(result.val[3]), 0);
         exp = UINT64_C(0x310098d161fa9bd4);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 3 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p16(result.val[3]), 1);
         exp = UINT64_C(0xf81b2bdc7c9f49b0);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 3 High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1556() {
#if __ARM_NEON_FP16_INTRINSICS

{
   {
      __fp16 arg1[4];
      float16x8x4_t arg2;
      float16x8x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"load4_lane\", fnname = \"vld4q_lane_f16\", rettype = \"float16x8x4_t\", argtypes = \"[__transfersize(4) __fp16 const *,float16x8x4_t,__constrange(0,7) int]\", vals = [PtrVal [FloatVal (-7.822023505707922),FloatVal 5.098460475329368,FloatVal 5.63038150142124,FloatVal (-9.19535158251235)],ArrayVal [VectorVal [FloatVal (-0.9790183240800943),FloatVal (-3.0165348695468186),FloatVal (-5.312505439984381),FloatVal 9.440454485787285,FloatVal 3.175215890236551,FloatVal 5.946064508336974,FloatVal (-8.039649325582745),FloatVal 1.2441211297924184],VectorVal [FloatVal (-7.698046303453943e-2),FloatVal (-4.607463995946437),FloatVal (-6.795921975819477),FloatVal (-5.985622898344241),FloatVal 3.866376192952906,FloatVal 6.472757131548612,FloatVal (-4.423053584728429),FloatVal (-8.618849834321436)],VectorVal [FloatVal 5.238561350052272,FloatVal (-7.573517487481849),FloatVal 8.271703149819022,FloatVal (-7.249384462670035),FloatVal 4.607985689543792,FloatVal (-4.105825767970246),FloatVal (-4.882235037620024),FloatVal (-6.269148958523168)],VectorVal [FloatVal 8.599273590032041,FloatVal 6.85056931357434,FloatVal (-3.970487705379611),FloatVal 9.529429758995466,FloatVal 8.779886606801568,FloatVal 7.984328480829902,FloatVal (-7.438638645139097),FloatVal 1.4450601380791674]],IndexVal 4], start_saturated = False}";
      int reported = 0;
      arg1[0] = -7.822023505707922;
      arg1[1] = 5.098460475329368;
      arg1[2] = 5.63038150142124;
      arg1[3] = -9.19535158251235;
      arg2.val[0] = vcombine_f16(vcreate_f16(UINT64_C(0x48b8c550c208bbd5)),
                                 vcreate_f16(UINT64_C(0x3cf9c80545f24259)));
      arg2.val[1] = vcombine_f16(vcreate_f16(UINT64_C(0xc5fcc6cbc49baced)),
                                 vcreate_f16(UINT64_C(0xc84fc46c467943bb)));
      arg2.val[2] = vcombine_f16(vcreate_f16(UINT64_C(0xc73f4822c792453d)),
                                 vcreate_f16(UINT64_C(0xc644c4e1c41b449b)));
      arg2.val[3] = vcombine_f16(vcreate_f16(UINT64_C(0x48c3c3f046d9484c)),
                                 vcreate_f16(UINT64_C(0x3dc7c77047fb4863)));
      clear_neon_saturated();
      //  Expect: "result" = 3dc7c77047fbc89948c3c3f046d9484cc644c4e1c41b45a1c73f4822c792453dc84fc46c46794519c5fcc6cbc49baced3cf9c80545f2c7d248b8c550c208bbd5
      result = vld4q_lane_f16(arg1, arg2, 4);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[0], 0);
         exp = -0.9790183240800943;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 0 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[0], 1);
         exp = -3.0165348695468186;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 1 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[0], 2);
         exp = -5.312505439984381;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 2 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[0], 3);
         exp = 9.440454485787285;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 3 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[0], 4);
         exp = -7.822023505707922;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 4 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[0], 5);
         exp = 5.946064508336974;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 5 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[0], 6);
         exp = -8.039649325582745;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 6 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[0], 7);
         exp = 1.2441211297924184;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 7 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[1], 0);
         exp = -7.698046303453943e-2;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 0 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[1], 1);
         exp = -4.607463995946437;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 1 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[1], 2);
         exp = -6.795921975819477;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 2 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[1], 3);
         exp = -5.985622898344241;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 3 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[1], 4);
         exp = 5.098460475329368;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 4 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[1], 5);
         exp = 6.472757131548612;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 5 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[1], 6);
         exp = -4.423053584728429;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 6 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[1], 7);
         exp = -8.618849834321436;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 7 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[2], 0);
         exp = 5.238561350052272;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 2 Lane 0 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[2], 1);
         exp = -7.573517487481849;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 2 Lane 1 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[2], 2);
         exp = 8.271703149819022;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 2 Lane 2 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[2], 3);
         exp = -7.249384462670035;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 2 Lane 3 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[2], 4);
         exp = 5.63038150142124;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 2 Lane 4 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[2], 5);
         exp = -4.105825767970246;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 2 Lane 5 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[2], 6);
         exp = -4.882235037620024;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 2 Lane 6 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[2], 7);
         exp = -6.269148958523168;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 2 Lane 7 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[3], 0);
         exp = 8.599273590032041;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 3 Lane 0 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[3], 1);
         exp = 6.85056931357434;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 3 Lane 1 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[3], 2);
         exp = -3.970487705379611;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 3 Lane 2 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[3], 3);
         exp = 9.529429758995466;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 3 Lane 3 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[3], 4);
         exp = -9.19535158251235;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 3 Lane 4 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[3], 5);
         exp = 7.984328480829902;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 3 Lane 5 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[3], 6);
         exp = -7.438638645139097;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 3 Lane 6 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result.val[3], 7);
         exp = 1.4450601380791674;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 3 Lane 7 ",
                      exp,
                      got);
            }
      }
   }
}
#endif
}
void dotests_1557() {

{
   {
      uint64_t arg1[4];
      uint64x2x4_t arg2;
      uint64x2x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"load4_lane\", fnname = \"vld4q_lane_u64\", rettype = \"uint64x2x4_t\", argtypes = \"[__transfersize(4) uint64_t const *,uint64x2x4_t,__constrange(0,1) int]\", vals = [PtrVal [IntegerVal 4592967934623574486,IntegerVal 140736123568128,IntegerVal 9015643506189777182,IntegerVal 9223133318277464063],ArrayVal [VectorVal [IntegerVal 4294945334,IntegerVal 9223231299366420479],VectorVal [IntegerVal 9223512774343131136,IntegerVal 140740345111174],VectorVal [IntegerVal 5341299317321826303,IntegerVal 281472829194239],VectorVal [IntegerVal 9223512774343098367,IntegerVal 10982559958049947648]],IndexVal 1], start_saturated = False}";
      int reported = 0;
      arg1[0] = UINT64_C(0x3fbd80007fff69d6);
      arg1[1] = UINT64_C(0x00007fffaea70000);
      arg1[2] = UINT64_C(0x7d1e00007fffb91e);
      arg1[3] = UINT64_C(0x7fff26e2ffff7fff);
      arg2.val[0] = vcombine_u64(vcreate_u64(UINT64_C(0x00000000ffffaa36)),
                                 vcreate_u64(UINT64_C(0x7fff7fffffffffff)));
      arg2.val[1] = vcombine_u64(vcreate_u64(UINT64_C(0x8000800000000000)),
                                 vcreate_u64(UINT64_C(0x00008000aa46a286)));
      arg2.val[2] = vcombine_u64(vcreate_u64(UINT64_C(0x4a201b6e0000ffff)),
                                 vcreate_u64(UINT64_C(0x0000ffff7fff7fff)));
      arg2.val[3] = vcombine_u64(vcreate_u64(UINT64_C(0x80007fffffff7fff)),
                                 vcreate_u64(UINT64_C(0x9869e417ffff0000)));
      clear_neon_saturated();
      //  Expect: "result" = 7fff26e2ffff7fff80007fffffff7fff7d1e00007fffb91e4a201b6e0000ffff00007fffaea7000080008000000000003fbd80007fff69d600000000ffffaa36
      result = vld4q_lane_u64(arg1, arg2, 1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result.val[0], 0);
         exp = UINT64_C(0x00000000ffffaa36);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result.val[0], 1);
         exp = UINT64_C(0x3fbd80007fff69d6);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result.val[1], 0);
         exp = UINT64_C(0x8000800000000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result.val[1], 1);
         exp = UINT64_C(0x00007fffaea70000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result.val[2], 0);
         exp = UINT64_C(0x4a201b6e0000ffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result.val[2], 1);
         exp = UINT64_C(0x7d1e00007fffb91e);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result.val[3], 0);
         exp = UINT64_C(0x80007fffffff7fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 3 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result.val[3], 1);
         exp = UINT64_C(0x7fff26e2ffff7fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 3 High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1558() {

{
   {
      int64_t arg1[4];
      int64x2x4_t arg2;
      int64x2x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"load4_lane\", fnname = \"vld4q_lane_s64\", rettype = \"int64x2x4_t\", argtypes = \"[__transfersize(4) int64_t const *,int64x2x4_t,__constrange(0,1) int]\", vals = [PtrVal [IntegerVal 9223372034707259392,IntegerVal 118764435701759,IntegerVal (-281470681776128),IntegerVal 55667071057920],ArrayVal [VectorVal [IntegerVal 26203595505664,IntegerVal (-7856107341777731584)],VectorVal [IntegerVal 9223372034707226624,IntegerVal (-281471286149120)],VectorVal [IntegerVal (-8996784682750246912),IntegerVal (-9223372034707292160)],VectorVal [IntegerVal (-9223231301513904128),IntegerVal 9223231301513969663]],IndexVal 1], start_saturated = False}";
      int reported = 0;
      arg1[0] = INT64_C(9223372034707259392);
      arg1[1] = INT64_C(118764435701759);
      arg1[2] = INT64_C(-281470681776128);
      arg1[3] = INT64_C(55667071057920);
      arg2.val[0] = vcombine_s64(vcreate_s64(UINT64_C(0x000017d500008000)),
                                 vcreate_s64(UINT64_C(0x92f97fff00000000)));
      arg2.val[1] = vcombine_s64(vcreate_s64(UINT64_C(0x7fffffff7fff0000)),
                                 vcreate_s64(UINT64_C(0xffff0000dbf98000)));
      arg2.val[2] = vcombine_s64(vcreate_s64(UINT64_C(0x8324ffff7fff0000)),
                                 vcreate_s64(UINT64_C(0x8000000080000000)));
      arg2.val[3] = vcombine_s64(vcreate_s64(UINT64_C(0x80007fff80000000)),
                                 vcreate_s64(UINT64_C(0x7fff80008000ffff)));
      clear_neon_saturated();
      //  Expect: "result" = 000032a0ffff000080007fff80000000ffff0000ffff80008324ffff7fff000000006c0400007fff7fffffff7fff00007fffffff7fff8000000017d500008000
      result = vld4q_lane_s64(arg1, arg2, 1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result.val[0]), 0);
         exp = UINT64_C(0x000017d500008000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result.val[0]), 1);
         exp = UINT64_C(0x7fffffff7fff8000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result.val[1]), 0);
         exp = UINT64_C(0x7fffffff7fff0000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result.val[1]), 1);
         exp = UINT64_C(0x00006c0400007fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result.val[2]), 0);
         exp = UINT64_C(0x8324ffff7fff0000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result.val[2]), 1);
         exp = UINT64_C(0xffff0000ffff8000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result.val[3]), 0);
         exp = UINT64_C(0x80007fff80000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 3 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result.val[3]), 1);
         exp = UINT64_C(0x000032a0ffff0000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 3 High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1559() {

{
   {
      poly64_t arg1[4];
      poly64x2x4_t arg2;
      poly64x2x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"load4_lane\", fnname = \"vld4q_lane_p64\", rettype = \"poly64x2x4_t\", argtypes = \"[__transfersize(4) poly64_t const *,poly64x2x4_t,__constrange(0,1) int]\", vals = [PtrVal [PolyVal [0,1,1,1,1,1,1,0,0,1,1,1,1,0,1,1,0,0,0,1,1,1,0,0,1,1,0,1,0,0,1,1,0,1,1,1,1,1,0,1,1,1,1,1,1,0,1,0,0,1,1,0,0,1,0,1,0,0,0,0,0,0,0,0],PolyVal [0,0,1,1,0,0,0,1,0,0,0,1,1,1,0,0,0,1,0,0,1,0,0,1,1,1,1,1,1,0,0,0,1,1,1,0,1,0,0,0,1,1,0,1,1,0,0,1,0,0,1,0,0,0,1,1,0,1,1,0,0,0,0,1],PolyVal [0,0,0,1,0,0,1,0,0,1,1,0,0,1,1,1,0,1,1,0,1,0,1,0,0,0,0,1,0,1,1,1,0,0,1,1,0,1,0,1,1,0,1,1,0,1,0,0,1,1,0,1,0,0,1,0,1,1,0,1,1,1,1,0],PolyVal [1,0,1,0,0,0,1,0,0,1,0,1,1,1,0,0,1,1,1,1,0,1,0,0,1,0,1,1,0,1,1,1,1,0,1,0,0,1,0,1,1,1,1,1,0,0,1,1,1,0,1,1,1,1,1,1,1,1,1,1,0,0,1,1]],ArrayVal [VectorVal [PolyVal [0,0,1,0,1,1,1,1,1,1,1,1,1,1,0,0,1,1,0,1,1,0,1,1,1,1,0,0,1,1,0,1,0,1,0,0,0,1,1,0,0,1,0,1,1,1,1,1,1,1,1,1,1,1,1,0,1,1,1,0,0,0,0,1],PolyVal [1,1,1,0,1,1,0,0,1,0,1,0,1,0,1,0,0,0,0,1,1,1,1,1,0,1,0,1,1,1,1,0,1,0,0,0,0,0,0,0,1,0,0,1,0,1,0,1,1,0,1,1,0,0,1,1,1,0,0,1,1,1,0,1]],VectorVal [PolyVal [1,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,1,1,1,1,0,1,1,1,0,1,0,1,0,1,1,1,1,0,1,1,0,0,0,0,0,0,1,0,1,1,0,1,0,0,0,0,1,1,1,1,0,0,1,1],PolyVal [0,1,1,0,0,0,0,1,1,1,0,0,0,1,0,1,1,0,0,1,1,1,1,0,1,1,1,1,0,0,0,0,1,1,1,1,0,1,1,1,1,1,0,1,0,0,1,1,0,0,0,0,1,1,0,1,1,1,1,0,1,0,0,0]],VectorVal [PolyVal [1,1,1,0,1,0,0,1,1,0,0,1,0,1,0,1,0,0,0,1,1,0,1,0,0,0,0,0,1,0,1,0,1,0,1,0,1,1,1,1,0,0,1,0,1,0,0,0,1,1,0,0,0,1,0,1,0,0,1,1,0,0,0,0],PolyVal [0,0,0,1,0,1,0,1,1,1,0,1,1,1,0,1,1,0,0,1,1,1,0,0,0,0,1,0,1,1,1,1,0,0,0,0,1,0,0,1,1,0,1,1,1,1,1,0,0,1,1,0,1,0,1,0,0,0,1,1,0,0,1,0]],VectorVal [PolyVal [0,1,0,0,0,1,1,0,0,1,1,0,0,1,0,0,0,0,0,1,1,1,1,0,0,1,0,1,1,1,1,0,1,0,1,0,1,1,1,1,1,0,0,0,1,1,0,0,1,0,0,0,0,1,0,1,0,0,1,0,0,1,1,0],PolyVal [1,0,1,1,1,1,1,0,0,1,0,1,0,0,0,1,0,1,1,0,0,0,1,1,1,0,0,0,1,0,0,1,0,0,1,1,1,0,1,0,0,0,0,1,1,0,0,0,1,1,1,0,1,0,0,0,1,1,1,1,1,0,0,1]]],IndexVal 1], start_saturated = False}";
      int reported = 0;
      arg1[0] = 46830119191895678;
      arg1[1] = -8735686853575690100;
      arg1[2] = 8884244910574069320;
      arg1[3] = -3459380627194824123;
      arg2.val[0] = vcombine_p64(vcreate_p64(UINT64_C(0x877ffa62b3db3ff4)),
                                 vcreate_p64(UINT64_C(0xb9cda9017af85537)));
      arg2.val[1] = vcombine_p64(vcreate_p64(UINT64_C(0xcf0b40deaef9400d)),
                                 vcreate_p64(UINT64_C(0x17b0cbef0f79a386)));
      arg2.val[2] = vcombine_p64(vcreate_p64(UINT64_C(0x0ca314f55058a997)),
                                 vcreate_p64(UINT64_C(0x4c567d90f439bba8)));
      arg2.val[3] = vcombine_p64(vcreate_p64(UINT64_C(0x64a131f57a782662)),
                                 vcreate_p64(UINT64_C(0x9f17185c91c68a7d)));
      clear_neon_saturated();
      //  Expect: "result" = cffdcfa5ed2f3a4564a131f57a7826627b4b2dace856e6480ca314f55058a99786c49b171f92388ccf0b40deaef9400d00a65fbecb38de7e877ffa62b3db3ff4
      result = vld4q_lane_p64(arg1, arg2, 1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p64(result.val[0]), 0);
         exp = UINT64_C(0x877ffa62b3db3ff4);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p64(result.val[0]), 1);
         exp = UINT64_C(0x00a65fbecb38de7e);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p64(result.val[1]), 0);
         exp = UINT64_C(0xcf0b40deaef9400d);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p64(result.val[1]), 1);
         exp = UINT64_C(0x86c49b171f92388c);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p64(result.val[2]), 0);
         exp = UINT64_C(0x0ca314f55058a997);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p64(result.val[2]), 1);
         exp = UINT64_C(0x7b4b2dace856e648);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p64(result.val[3]), 0);
         exp = UINT64_C(0x64a131f57a782662);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 3 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p64(result.val[3]), 1);
         exp = UINT64_C(0xcffdcfa5ed2f3a45);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 3 High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1560() {

{
   {
      uint8_t arg1[4];
      uint8x8x4_t arg2;
      uint8x8x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"load4_lane\", fnname = \"vld4_lane_u8\", rettype = \"uint8x8x4_t\", argtypes = \"[__transfersize(4) uint8_t const *,uint8x8x4_t,__constrange(0,7) int]\", vals = [PtrVal [IntegerVal 157,IntegerVal 0,IntegerVal 0,IntegerVal 127],ArrayVal [VectorVal [IntegerVal 128,IntegerVal 255,IntegerVal 127,IntegerVal 255,IntegerVal 128,IntegerVal 127,IntegerVal 0,IntegerVal 0],VectorVal [IntegerVal 127,IntegerVal 255,IntegerVal 127,IntegerVal 83,IntegerVal 128,IntegerVal 255,IntegerVal 127,IntegerVal 127],VectorVal [IntegerVal 253,IntegerVal 127,IntegerVal 241,IntegerVal 192,IntegerVal 128,IntegerVal 127,IntegerVal 127,IntegerVal 176],VectorVal [IntegerVal 89,IntegerVal 0,IntegerVal 128,IntegerVal 128,IntegerVal 72,IntegerVal 127,IntegerVal 127,IntegerVal 0]],IndexVal 6], start_saturated = False}";
      int reported = 0;
      arg1[0] = 157U;
      arg1[1] = 0;
      arg1[2] = 0;
      arg1[3] = 127U;
      arg2.val[0] = vcreate_u8(UINT64_C(0x00007f80ff7fff80));
      arg2.val[1] = vcreate_u8(UINT64_C(0x7f7fff80537fff7f));
      arg2.val[2] = vcreate_u8(UINT64_C(0xb07f7f80c0f17ffd));
      arg2.val[3] = vcreate_u8(UINT64_C(0x007f7f4880800059));
      clear_neon_saturated();
      //  Expect: "result" = 007f7f4880800059b0007f80c0f17ffd7f00ff80537fff7f009d7f80ff7fff80
      result = vld4_lane_u8(arg1, arg2, 6);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_u8(result.val[0]), 0);
         exp = UINT64_C(0x009d7f80ff7fff80);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_u8(result.val[1]), 0);
         exp = UINT64_C(0x7f00ff80537fff7f);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_u8(result.val[2]), 0);
         exp = UINT64_C(0xb0007f80c0f17ffd);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_u8(result.val[3]), 0);
         exp = UINT64_C(0x007f7f4880800059);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 3 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1561() {

{
   {
      uint16_t arg1[4];
      uint16x4x4_t arg2;
      uint16x4x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"load4_lane\", fnname = \"vld4_lane_u16\", rettype = \"uint16x4x4_t\", argtypes = \"[__transfersize(4) uint16_t const *,uint16x4x4_t,__constrange(0,3) int]\", vals = [PtrVal [IntegerVal 65535,IntegerVal 32767,IntegerVal 32767,IntegerVal 32767],ArrayVal [VectorVal [IntegerVal 32768,IntegerVal 65535,IntegerVal 32767,IntegerVal 54449],VectorVal [IntegerVal 40944,IntegerVal 12282,IntegerVal 32768,IntegerVal 32767],VectorVal [IntegerVal 27168,IntegerVal 0,IntegerVal 32768,IntegerVal 32767],VectorVal [IntegerVal 32768,IntegerVal 32767,IntegerVal 0,IntegerVal 36016]],IndexVal 0], start_saturated = False}";
      int reported = 0;
      arg1[0] = 65535U;
      arg1[1] = 32767U;
      arg1[2] = 32767U;
      arg1[3] = 32767U;
      arg2.val[0] = vcreate_u16(UINT64_C(0xd4b17fffffff8000));
      arg2.val[1] = vcreate_u16(UINT64_C(0x7fff80002ffa9ff0));
      arg2.val[2] = vcreate_u16(UINT64_C(0x7fff800000006a20));
      arg2.val[3] = vcreate_u16(UINT64_C(0x8cb000007fff8000));
      clear_neon_saturated();
      //  Expect: "result" = 8cb000007fff7fff7fff800000007fff7fff80002ffa7fffd4b17fffffffffff
      result = vld4_lane_u16(arg1, arg2, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_u16(result.val[0]), 0);
         exp = UINT64_C(0xd4b17fffffffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_u16(result.val[1]), 0);
         exp = UINT64_C(0x7fff80002ffa7fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_u16(result.val[2]), 0);
         exp = UINT64_C(0x7fff800000007fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_u16(result.val[3]), 0);
         exp = UINT64_C(0x8cb000007fff7fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 3 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1562() {

{
   {
      uint32_t arg1[4];
      uint32x2x4_t arg2;
      uint32x2x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"load4_lane\", fnname = \"vld4_lane_u32\", rettype = \"uint32x2x4_t\", argtypes = \"[__transfersize(4) uint32_t const *,uint32x2x4_t,__constrange(0,1) int]\", vals = [PtrVal [IntegerVal 2147418112,IntegerVal 65535,IntegerVal 389119999,IntegerVal 2705298768],ArrayVal [VectorVal [IntegerVal 2147532223,IntegerVal 4294934528],VectorVal [IntegerVal 2147498872,IntegerVal 4294967295],VectorVal [IntegerVal 1254817792,IntegerVal 2147549183],VectorVal [IntegerVal 4294934528,IntegerVal 3539599360]],IndexVal 0], start_saturated = False}";
      int reported = 0;
      arg1[0] = 2147418112U;
      arg1[1] = 65535U;
      arg1[2] = 389119999U;
      arg1[3] = 2705298768U;
      arg2.val[0] = vcreate_u32(UINT64_C(0xffff80008000bdbf));
      arg2.val[1] = vcreate_u32(UINT64_C(0xffffffff80003b78));
      arg2.val[2] = vcreate_u32(UINT64_C(0x8000ffff4acb0000));
      arg2.val[3] = vcreate_u32(UINT64_C(0xd2fa0000ffff8000));
      clear_neon_saturated();
      //  Expect: "result" = d2fa0000a13f95508000ffff17317fffffffffff0000ffffffff80007fff0000
      result = vld4_lane_u32(arg1, arg2, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_u32(result.val[0]), 0);
         exp = UINT64_C(0xffff80007fff0000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_u32(result.val[1]), 0);
         exp = UINT64_C(0xffffffff0000ffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_u32(result.val[2]), 0);
         exp = UINT64_C(0x8000ffff17317fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_u32(result.val[3]), 0);
         exp = UINT64_C(0xd2fa0000a13f9550);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 3 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1563() {

{
   {
      int8_t arg1[4];
      int8x8x4_t arg2;
      int8x8x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"load4_lane\", fnname = \"vld4_lane_s8\", rettype = \"int8x8x4_t\", argtypes = \"[__transfersize(4) int8_t const *,int8x8x4_t,__constrange(0,7) int]\", vals = [PtrVal [IntegerVal 77,IntegerVal (-128),IntegerVal (-128),IntegerVal 85],ArrayVal [VectorVal [IntegerVal (-128),IntegerVal 0,IntegerVal (-128),IntegerVal 0,IntegerVal 0,IntegerVal 93,IntegerVal (-1),IntegerVal 0],VectorVal [IntegerVal (-1),IntegerVal 127,IntegerVal (-1),IntegerVal (-128),IntegerVal 127,IntegerVal (-128),IntegerVal 127,IntegerVal 127],VectorVal [IntegerVal (-1),IntegerVal (-122),IntegerVal 0,IntegerVal (-1),IntegerVal (-47),IntegerVal (-128),IntegerVal 0,IntegerVal 0],VectorVal [IntegerVal (-128),IntegerVal 127,IntegerVal (-128),IntegerVal (-128),IntegerVal 0,IntegerVal 0,IntegerVal (-128),IntegerVal (-128)]],IndexVal 0], start_saturated = False}";
      int reported = 0;
      arg1[0] = 77;
      arg1[1] = -128;
      arg1[2] = -128;
      arg1[3] = 85;
      arg2.val[0] = vcreate_s8(UINT64_C(0x00ff5d0000800080));
      arg2.val[1] = vcreate_s8(UINT64_C(0x7f7f807f80ff7fff));
      arg2.val[2] = vcreate_s8(UINT64_C(0x000080d1ff0086ff));
      arg2.val[3] = vcreate_s8(UINT64_C(0x8080000080807f80));
      clear_neon_saturated();
      //  Expect: "result" = 8080000080807f55000080d1ff0086807f7f807f80ff7f8000ff5d000080004d
      result = vld4_lane_s8(arg1, arg2, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_s8(result.val[0]), 0);
         exp = UINT64_C(0x00ff5d000080004d);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_s8(result.val[1]), 0);
         exp = UINT64_C(0x7f7f807f80ff7f80);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_s8(result.val[2]), 0);
         exp = UINT64_C(0x000080d1ff008680);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_s8(result.val[3]), 0);
         exp = UINT64_C(0x8080000080807f55);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 3 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1564() {

{
   {
      int16_t arg1[4];
      int16x4x4_t arg2;
      int16x4x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"load4_lane\", fnname = \"vld4_lane_s16\", rettype = \"int16x4x4_t\", argtypes = \"[__transfersize(4) int16_t const *,int16x4x4_t,__constrange(0,3) int]\", vals = [PtrVal [IntegerVal 0,IntegerVal 0,IntegerVal 18144,IntegerVal 0],ArrayVal [VectorVal [IntegerVal 0,IntegerVal 32767,IntegerVal (-1),IntegerVal 8126],VectorVal [IntegerVal 32767,IntegerVal (-1),IntegerVal (-1),IntegerVal (-15074)],VectorVal [IntegerVal (-2146),IntegerVal 7706,IntegerVal 32767,IntegerVal (-32768)],VectorVal [IntegerVal (-8789),IntegerVal 0,IntegerVal 32767,IntegerVal 32767]],IndexVal 2], start_saturated = False}";
      int reported = 0;
      arg1[0] = 0;
      arg1[1] = 0;
      arg1[2] = 18144;
      arg1[3] = 0;
      arg2.val[0] = vcreate_s16(UINT64_C(0x1fbeffff7fff0000));
      arg2.val[1] = vcreate_s16(UINT64_C(0xc51effffffff7fff));
      arg2.val[2] = vcreate_s16(UINT64_C(0x80007fff1e1af79e));
      arg2.val[3] = vcreate_s16(UINT64_C(0x7fff7fff0000ddab));
      clear_neon_saturated();
      //  Expect: "result" = 7fff00000000ddab800046e01e1af79ec51e0000ffff7fff1fbe00007fff0000
      result = vld4_lane_s16(arg1, arg2, 2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_s16(result.val[0]), 0);
         exp = UINT64_C(0x1fbe00007fff0000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_s16(result.val[1]), 0);
         exp = UINT64_C(0xc51e0000ffff7fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_s16(result.val[2]), 0);
         exp = UINT64_C(0x800046e01e1af79e);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_s16(result.val[3]), 0);
         exp = UINT64_C(0x7fff00000000ddab);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 3 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1565() {

{
   {
      int32_t arg1[4];
      int32x2x4_t arg2;
      int32x2x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"load4_lane\", fnname = \"vld4_lane_s32\", rettype = \"int32x2x4_t\", argtypes = \"[__transfersize(4) int32_t const *,int32x2x4_t,__constrange(0,1) int]\", vals = [PtrVal [IntegerVal 457899024,IntegerVal 1183303043,IntegerVal 32768,IntegerVal (-702251009)],ArrayVal [VectorVal [IntegerVal 2147418112,IntegerVal 65535],VectorVal [IntegerVal (-65536),IntegerVal (-843972608)],VectorVal [IntegerVal (-32769),IntegerVal (-2147418113)],VectorVal [IntegerVal 65535,IntegerVal 1393491968]],IndexVal 1], start_saturated = False}";
      int reported = 0;
      arg1[0] = 457899024;
      arg1[1] = 1183303043;
      arg1[2] = 32768;
      arg1[3] = -702251009;
      arg2.val[0] = vcreate_s32(UINT64_C(0x0000ffff7fff0000));
      arg2.val[1] = vcreate_s32(UINT64_C(0xcdb20000ffff0000));
      arg2.val[2] = vcreate_s32(UINT64_C(0x8000ffffffff7fff));
      arg2.val[3] = vcreate_s32(UINT64_C(0x530f00000000ffff));
      clear_neon_saturated();
      //  Expect: "result" = d6247fff0000ffff00008000ffff7fff4687c583ffff00001b4afc107fff0000
      result = vld4_lane_s32(arg1, arg2, 1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_s32(result.val[0]), 0);
         exp = UINT64_C(0x1b4afc107fff0000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_s32(result.val[1]), 0);
         exp = UINT64_C(0x4687c583ffff0000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_s32(result.val[2]), 0);
         exp = UINT64_C(0x00008000ffff7fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_s32(result.val[3]), 0);
         exp = UINT64_C(0xd6247fff0000ffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 3 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1566() {

{
   {
      float32_t arg1[4];
      float32x2x4_t arg2;
      float32x2x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"load4_lane\", fnname = \"vld4_lane_f32\", rettype = \"float32x2x4_t\", argtypes = \"[__transfersize(4) float32_t const *,float32x2x4_t,__constrange(0,1) int]\", vals = [PtrVal [FloatVal 0.7297406196594238,FloatVal 0.9513905048370361,FloatVal 0.507580041885376,FloatVal 0.8285157084465027],ArrayVal [VectorVal [FloatVal 0.950605034828186,FloatVal 0.5038103461265564],VectorVal [FloatVal 0.920423686504364,FloatVal 0.389732301235199],VectorVal [FloatVal 0.8724597096443176,FloatVal 0.6744426488876343],VectorVal [FloatVal 0.5575872659683228,FloatVal 0.12389683723449707]],IndexVal 1], start_saturated = False}";
      int reported = 0;
      arg1[0] = ((float32_t) 0.7297406196594238);
      arg1[1] = ((float32_t) 0.9513905048370361);
      arg1[2] = ((float32_t) 0.507580041885376);
      arg1[3] = ((float32_t) 0.8285157084465027);
      arg2.val[0] = vcreate_f32(UINT64_C(0x3f00f9b73f735ada));
      arg2.val[1] = vcreate_f32(UINT64_C(0x3ec78afe3f6ba0e3));
      arg2.val[2] = vcreate_f32(UINT64_C(0x3f2ca8463f5f5985));
      arg2.val[3] = vcreate_f32(UINT64_C(0x3dfdbda03f0ebe0a));
      clear_neon_saturated();
      //  Expect: "result" = 3f54199b3f0ebe0a3f01f0c43f5f59853f738e543f6ba0e33f3ad0483f735ada
      result = vld4_lane_f32(arg1, arg2, 1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result.val[0], 0);
         exp = ((float32_t) 0.950605034828186);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 0 ",
                      exp,
                      got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result.val[0], 1);
         exp = ((float32_t) 0.7297406196594238);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 1 ",
                      exp,
                      got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result.val[1], 0);
         exp = ((float32_t) 0.920423686504364);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 0 ",
                      exp,
                      got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result.val[1], 1);
         exp = ((float32_t) 0.9513905048370361);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 1 ",
                      exp,
                      got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result.val[2], 0);
         exp = ((float32_t) 0.8724597096443176);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 2 Lane 0 ",
                      exp,
                      got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result.val[2], 1);
         exp = ((float32_t) 0.507580041885376);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 2 Lane 1 ",
                      exp,
                      got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result.val[3], 0);
         exp = ((float32_t) 0.5575872659683228);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 3 Lane 0 ",
                      exp,
                      got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result.val[3], 1);
         exp = ((float32_t) 0.8285157084465027);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 3 Lane 1 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1567() {

{
   {
      float64_t arg1[4];
      float64x1x4_t arg2;
      float64x1x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"load4_lane\", fnname = \"vld4_lane_f64\", rettype = \"float64x1x4_t\", argtypes = \"[__transfersize(4) float64_t const *,float64x1x4_t,__constrange(0,0) int]\", vals = [PtrVal [FloatVal 0.476357716148486,FloatVal 0.73224398975449,FloatVal 0.9980617533154796,FloatVal 0.9130493102363931],ArrayVal [VectorVal [FloatVal 0.8604373855775781],VectorVal [FloatVal 0.3715304483217766],VectorVal [FloatVal 0.34133034817220465],VectorVal [FloatVal 0.12612580186756683]],IndexVal 0], start_saturated = False}";
      int reported = 0;
      arg1[0] = 0.476357716148486;
      arg1[1] = 0.73224398975449;
      arg1[2] = 0.9980617533154796;
      arg1[3] = 0.9130493102363931;
      arg2.val[0] = vcreate_f64(UINT64_C(0x3feb88b3fbe9f751));
      arg2.val[1] = vcreate_f64(UINT64_C(0x3fd7c727a540a7ea));
      arg2.val[2] = vcreate_f64(UINT64_C(0x3fd5d85b3ea20ada));
      arg2.val[3] = vcreate_f64(UINT64_C(0x3fc024e3e919fb18));
      clear_neon_saturated();
      //  Expect: "result" = 3fed37b32fe338a93feff01f33bc1be43fe76e8af29604dd3fde7ca513038518
      result = vld4_lane_f64(arg1, arg2, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float64_t got;
         float64_t exp;
         got = vget_lane_f64(result.val[0], 0);
         exp = 0.476357716148486;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 0 ",
                      exp,
                      got);
            }
      }
      {
         float64_t got;
         float64_t exp;
         got = vget_lane_f64(result.val[1], 0);
         exp = 0.73224398975449;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 0 ",
                      exp,
                      got);
            }
      }
      {
         float64_t got;
         float64_t exp;
         got = vget_lane_f64(result.val[2], 0);
         exp = 0.9980617533154796;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 2 Lane 0 ",
                      exp,
                      got);
            }
      }
      {
         float64_t got;
         float64_t exp;
         got = vget_lane_f64(result.val[3], 0);
         exp = 0.9130493102363931;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 3 Lane 0 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1568() {

{
   {
      poly8_t arg1[4];
      poly8x8x4_t arg2;
      poly8x8x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"load4_lane\", fnname = \"vld4_lane_p8\", rettype = \"poly8x8x4_t\", argtypes = \"[__transfersize(4) poly8_t const *,poly8x8x4_t,__constrange(0,7) int]\", vals = [PtrVal [PolyVal [0,0,1,1,1,0,0,0],PolyVal [1,1,0,1,0,1,0,1],PolyVal [1,1,1,0,1,1,0,1],PolyVal [0,1,0,1,0,1,0,0]],ArrayVal [VectorVal [PolyVal [0,0,1,1,0,1,1,1],PolyVal [1,1,0,1,0,1,0,0],PolyVal [0,0,1,0,0,1,1,1],PolyVal [1,0,1,0,0,1,0,1],PolyVal [0,1,1,1,1,1,1,1],PolyVal [0,1,0,0,0,0,0,1],PolyVal [1,1,1,1,1,0,0,1],PolyVal [1,1,1,0,1,0,1,1]],VectorVal [PolyVal [1,0,0,0,0,0,1,0],PolyVal [0,0,1,1,1,1,0,0],PolyVal [0,0,0,1,1,0,0,0],PolyVal [0,1,1,1,1,1,0,1],PolyVal [0,1,1,0,1,1,1,1],PolyVal [1,0,1,0,1,1,1,0],PolyVal [1,1,1,1,1,1,0,1],PolyVal [0,1,1,0,1,1,0,0]],VectorVal [PolyVal [1,1,0,1,0,1,1,1],PolyVal [0,0,0,1,1,1,0,0],PolyVal [0,0,1,0,0,0,0,0],PolyVal [1,0,1,0,1,0,0,0],PolyVal [1,0,1,1,1,0,0,0],PolyVal [0,1,1,1,1,0,0,1],PolyVal [1,1,0,0,0,1,1,1],PolyVal [0,1,0,1,1,0,1,0]],VectorVal [PolyVal [0,1,0,1,0,1,1,0],PolyVal [1,0,1,1,0,0,0,0],PolyVal [1,1,0,1,1,1,1,0],PolyVal [1,1,0,1,1,0,1,0],PolyVal [0,1,1,1,1,1,1,0],PolyVal [1,1,0,0,1,0,0,1],PolyVal [1,0,0,0,1,1,0,0],PolyVal [1,1,0,0,1,1,1,0]]],IndexVal 3], start_saturated = False}";
      int reported = 0;
      arg1[0] = 28;
      arg1[1] = 171;
      arg1[2] = 183;
      arg1[3] = 42;
      arg2.val[0] = vcreate_p8(UINT64_C(0xd79f82fea5e42bec));
      arg2.val[1] = vcreate_p8(UINT64_C(0x36bf75f6be183c41));
      arg2.val[2] = vcreate_p8(UINT64_C(0x5ae39e1d150438eb));
      arg2.val[3] = vcreate_p8(UINT64_C(0x7331937e5b7b0d6a));
      clear_neon_saturated();
      //  Expect: "result" = 7331937e2a7b0d6a5ae39e1db70438eb36bf75f6ab183c41d79f82fe1ce42bec
      result = vld4_lane_p8(arg1, arg2, 3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_p8(result.val[0]), 0);
         exp = UINT64_C(0xd79f82fe1ce42bec);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_p8(result.val[1]), 0);
         exp = UINT64_C(0x36bf75f6ab183c41);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_p8(result.val[2]), 0);
         exp = UINT64_C(0x5ae39e1db70438eb);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_p8(result.val[3]), 0);
         exp = UINT64_C(0x7331937e2a7b0d6a);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 3 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1569() {

{
   {
      poly16_t arg1[4];
      poly16x4x4_t arg2;
      poly16x4x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"load4_lane\", fnname = \"vld4_lane_p16\", rettype = \"poly16x4x4_t\", argtypes = \"[__transfersize(4) poly16_t const *,poly16x4x4_t,__constrange(0,3) int]\", vals = [PtrVal [PolyVal [1,0,1,0,0,1,1,1,1,1,1,1,0,1,1,1],PolyVal [0,0,0,1,1,0,1,0,1,0,1,0,0,1,0,0],PolyVal [0,1,1,0,1,1,0,0,0,0,0,0,0,0,1,1],PolyVal [1,1,0,1,0,1,0,1,1,0,0,1,0,1,0,1]],ArrayVal [VectorVal [PolyVal [0,1,1,0,0,1,1,0,1,0,1,1,0,1,1,1],PolyVal [0,1,1,1,0,0,0,1,0,0,1,1,0,0,1,0],PolyVal [0,0,0,0,0,1,0,0,0,0,1,1,1,0,0,0],PolyVal [1,1,0,0,0,0,0,0,1,0,1,0,0,0,1,1]],VectorVal [PolyVal [0,0,0,1,1,0,1,1,0,1,0,1,1,1,1,0],PolyVal [1,1,0,1,1,1,0,1,0,0,0,0,0,0,1,1],PolyVal [1,0,1,1,0,1,0,0,1,1,0,0,0,0,0,0],PolyVal [0,0,0,1,1,1,0,0,1,0,1,0,1,0,0,1]],VectorVal [PolyVal [1,1,0,0,1,0,1,1,0,0,0,1,0,1,0,1],PolyVal [0,1,0,1,1,0,1,0,0,1,1,1,0,1,0,0],PolyVal [0,1,1,1,0,0,0,0,1,0,1,0,1,0,1,1],PolyVal [1,1,1,0,0,1,0,0,1,0,1,0,1,1,0,0]],VectorVal [PolyVal [0,1,1,0,1,0,0,0,0,1,1,0,0,1,0,1],PolyVal [1,0,0,0,1,0,0,0,0,0,1,1,1,0,1,1],PolyVal [0,1,0,0,0,0,1,1,0,1,1,1,0,1,1,0],PolyVal [0,1,1,1,0,0,1,0,1,0,1,0,1,0,0,0]]],IndexVal 3], start_saturated = False}";
      int reported = 0;
      arg1[0] = 61413;
      arg1[1] = 9560;
      arg1[2] = 49206;
      arg1[3] = 43435;
      arg2.val[0] = vcreate_p16(UINT64_C(0xc5031c204c8eed66));
      arg2.val[1] = vcreate_p16(UINT64_C(0x9538032dc0bb7ad8));
      arg2.val[2] = vcreate_p16(UINT64_C(0x3527d50e2e5aa8d3));
      arg2.val[3] = vcreate_p16(UINT64_C(0x154e6ec2dc11a616));
      clear_neon_saturated();
      //  Expect: "result" = a9ab6ec2dc11a616c036d50e2e5aa8d32558032dc0bb7ad8efe51c204c8eed66
      result = vld4_lane_p16(arg1, arg2, 3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_p16(result.val[0]), 0);
         exp = UINT64_C(0xefe51c204c8eed66);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_p16(result.val[1]), 0);
         exp = UINT64_C(0x2558032dc0bb7ad8);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_p16(result.val[2]), 0);
         exp = UINT64_C(0xc036d50e2e5aa8d3);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_p16(result.val[3]), 0);
         exp = UINT64_C(0xa9ab6ec2dc11a616);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 3 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1570() {
#if __ARM_NEON_FP16_INTRINSICS

{
   {
      __fp16 arg1[4];
      float16x4x4_t arg2;
      float16x4x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"load4_lane\", fnname = \"vld4_lane_f16\", rettype = \"float16x4x4_t\", argtypes = \"[__transfersize(4) __fp16 const *,float16x4x4_t,__constrange(0,3) int]\", vals = [PtrVal [FloatVal 2.092230196222866,FloatVal 0.6520759604819872,FloatVal 3.617326383589825,FloatVal 0.49901636140631034],ArrayVal [VectorVal [FloatVal 6.169063322012359,FloatVal 1.3529541052223522,FloatVal (-5.186012065151775),FloatVal 6.541788627341738],VectorVal [FloatVal (-8.16048337095674),FloatVal (-4.561480979639276),FloatVal (-1.4355001890594394),FloatVal (-3.7345397612180804)],VectorVal [FloatVal (-4.481715541649196),FloatVal (-9.700770398931802),FloatVal 4.647977397626118,FloatVal 8.542725106185241],VectorVal [FloatVal 3.5360678454174845,FloatVal (-1.9154408244688526),FloatVal (-2.3231975636289004),FloatVal (-2.385938696391852)]],IndexVal 1], start_saturated = False}";
      int reported = 0;
      arg1[0] = 2.092230196222866;
      arg1[1] = 0.6520759604819872;
      arg1[2] = 3.617326383589825;
      arg1[3] = 0.49901636140631034;
      arg2.val[0] = vcreate_f16(UINT64_C(0x468ac52f3d69462b));
      arg2.val[1] = vcreate_f16(UINT64_C(0xc378bdbdc48fc814));
      arg2.val[2] = vcreate_f16(UINT64_C(0x484544a5c8d9c47b));
      arg2.val[3] = vcreate_f16(UINT64_C(0xc0c5c0a5bfa94312));
      clear_neon_saturated();
      //  Expect: "result" = c0c5c0a537fb4312484544a5433cc47bc378bdbd3937c814468ac52f402f462b
      result = vld4_lane_f16(arg1, arg2, 1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         __fp16 got;
         __fp16 exp;
         got = vget_lane_f16(result.val[0], 0);
         exp = 6.169063322012359;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 0 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vget_lane_f16(result.val[0], 1);
         exp = 2.092230196222866;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 1 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vget_lane_f16(result.val[0], 2);
         exp = -5.186012065151775;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 2 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vget_lane_f16(result.val[0], 3);
         exp = 6.541788627341738;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 3 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vget_lane_f16(result.val[1], 0);
         exp = -8.16048337095674;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 0 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vget_lane_f16(result.val[1], 1);
         exp = 0.6520759604819872;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 1 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vget_lane_f16(result.val[1], 2);
         exp = -1.4355001890594394;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 2 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vget_lane_f16(result.val[1], 3);
         exp = -3.7345397612180804;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 3 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vget_lane_f16(result.val[2], 0);
         exp = -4.481715541649196;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 2 Lane 0 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vget_lane_f16(result.val[2], 1);
         exp = 3.617326383589825;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 2 Lane 1 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vget_lane_f16(result.val[2], 2);
         exp = 4.647977397626118;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 2 Lane 2 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vget_lane_f16(result.val[2], 3);
         exp = 8.542725106185241;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 2 Lane 3 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vget_lane_f16(result.val[3], 0);
         exp = 3.5360678454174845;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 3 Lane 0 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vget_lane_f16(result.val[3], 1);
         exp = 0.49901636140631034;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 3 Lane 1 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vget_lane_f16(result.val[3], 2);
         exp = -2.3231975636289004;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 3 Lane 2 ",
                      exp,
                      got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vget_lane_f16(result.val[3], 3);
         exp = -2.385938696391852;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 3 Lane 3 ",
                      exp,
                      got);
            }
      }
   }
}
#endif
}
void dotests_1571() {

{
   {
      uint64_t arg1[4];
      uint64x1x4_t arg2;
      uint64x1x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"load4_lane\", fnname = \"vld4_lane_u64\", rettype = \"uint64x1x4_t\", argtypes = \"[__transfersize(4) uint64_t const *,uint64x1x4_t,__constrange(0,0) int]\", vals = [PtrVal [IntegerVal 17760226601217341821,IntegerVal 5722527014015926272,IntegerVal 18446744071562035200,IntegerVal 255098880],ArrayVal [VectorVal [IntegerVal 18446462602167386111],VectorVal [IntegerVal 9803914174172954624],VectorVal [IntegerVal 18446603337390292991],VectorVal [IntegerVal 17743901059010592767]],IndexVal 0], start_saturated = False}";
      int reported = 0;
      arg1[0] = UINT64_C(0xf678ffff0000b97d);
      arg1[1] = UINT64_C(0x4f6a7fffffff0000);
      arg1[2] = UINT64_C(0xffffffff7fff8000);
      arg1[3] = UINT64_C(0x000000000f348000);
      arg2.val[0] = vcreate_u64(UINT64_C(0xffff0000ccb6ffff));
      arg2.val[1] = vcreate_u64(UINT64_C(0x880e7fff7fff0000));
      arg2.val[2] = vcreate_u64(UINT64_C(0xffff800045aeffff));
      arg2.val[3] = vcreate_u64(UINT64_C(0xf63f00008000ffff));
      clear_neon_saturated();
      //  Expect: "result" = 000000000f348000ffffffff7fff80004f6a7fffffff0000f678ffff0000b97d
      result = vld4_lane_u64(arg1, arg2, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(result.val[0], 0);
         exp = UINT64_C(0xf678ffff0000b97d);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(result.val[1], 0);
         exp = UINT64_C(0x4f6a7fffffff0000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(result.val[2], 0);
         exp = UINT64_C(0xffffffff7fff8000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(result.val[3], 0);
         exp = UINT64_C(0x000000000f348000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 3 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1572() {

{
   {
      int64_t arg1[4];
      int64x1x4_t arg2;
      int64x1x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"load4_lane\", fnname = \"vld4_lane_s64\", rettype = \"int64x1x4_t\", argtypes = \"[__transfersize(4) int64_t const *,int64x1x4_t,__constrange(0,0) int]\", vals = [PtrVal [IntegerVal 2147483648,IntegerVal 9223090564025581568,IntegerVal (-9223231301513936897),IntegerVal (-9223372034707292160)],ArrayVal [VectorVal [IntegerVal (-140741272666112)],VectorVal [IntegerVal 5621477501671782670],VectorVal [IntegerVal (-281472951222272)],VectorVal [IntegerVal (-9223231299366461818)]],IndexVal 0], start_saturated = False}";
      int reported = 0;
      arg1[0] = INT64_C(2147483648);
      arg1[1] = INT64_C(9223090564025581568);
      arg1[2] = INT64_C(-9223231301513936897);
      arg1[3] = INT64_C(-9223372034707292160);
      arg2.val[0] = vcreate_s64(UINT64_C(0xffff7fff1e700000));
      arg2.val[1] = vcreate_s64(UINT64_C(0x4e038000ffff390e));
      arg2.val[2] = vcreate_s64(UINT64_C(0xffff000078ba8000));
      arg2.val[3] = vcreate_s64(UINT64_C(0x80007fffffff5e86));
      clear_neon_saturated();
      //  Expect: "result" = 800000008000000080007fff7fff7fff7fff0000800080000000000080000000
      result = vld4_lane_s64(arg1, arg2, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_s64(result.val[0]), 0);
         exp = UINT64_C(0x0000000080000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_s64(result.val[1]), 0);
         exp = UINT64_C(0x7fff000080008000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_s64(result.val[2]), 0);
         exp = UINT64_C(0x80007fff7fff7fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_s64(result.val[3]), 0);
         exp = UINT64_C(0x8000000080000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 3 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1573() {

{
   {
      poly64_t arg1[4];
      poly64x1x4_t arg2;
      poly64x1x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"load4_lane\", fnname = \"vld4_lane_p64\", rettype = \"poly64x1x4_t\", argtypes = \"[__transfersize(4) poly64_t const *,poly64x1x4_t,__constrange(0,0) int]\", vals = [PtrVal [PolyVal [0,0,0,0,0,0,1,1,1,1,1,0,1,0,1,1,0,1,1,0,1,1,0,0,1,0,0,1,0,0,0,0,1,0,1,0,1,0,1,1,1,0,1,1,0,1,1,1,0,1,0,1,1,1,1,0,0,1,0,1,1,1,1,0],PolyVal [0,0,0,1,1,0,1,0,1,1,1,1,1,1,0,0,1,0,1,1,0,0,0,1,0,1,1,1,0,1,1,0,0,0,1,0,0,1,1,1,1,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0],PolyVal [0,0,1,1,0,1,1,1,0,1,1,0,0,0,1,0,1,1,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,1,0,1,1,1,0,1,1,1,0,1,0,1,0,1,0,1,0,1,0,1,1,0,0,1,1,0,0,0],PolyVal [1,0,0,0,1,0,1,0,1,0,0,0,0,1,0,1,1,0,1,0,1,0,1,1,0,1,1,1,0,1,1,1,1,1,1,1,1,0,1,1,1,1,1,1,1,1,1,0,0,0,1,1,1,0,0,0,0,0,1,0,0,0,0,1]],ArrayVal [VectorVal [PolyVal [1,1,1,1,1,1,1,1,0,1,1,0,0,1,1,0,1,0,1,0,1,0,1,0,0,1,1,1,0,1,1,0,1,0,1,1,0,1,1,1,1,0,0,0,1,1,1,1,0,0,1,0,1,1,1,0,1,1,0,0,0,0,0,0]],VectorVal [PolyVal [0,1,1,0,0,0,0,1,0,1,1,1,0,1,1,1,1,0,0,0,1,1,1,1,1,1,1,0,1,1,0,0,0,1,1,0,0,0,0,0,0,0,1,1,1,1,1,0,0,0,1,1,0,0,1,0,1,0,0,1,0,1,0,1]],VectorVal [PolyVal [0,1,1,0,1,1,0,1,0,0,0,0,0,1,1,0,1,1,1,0,0,0,0,0,1,1,0,1,0,0,1,1,1,1,0,0,0,0,1,1,1,1,0,1,0,1,1,0,0,1,0,0,1,1,1,0,1,1,1,1,1,1,1,1]],VectorVal [PolyVal [1,0,0,1,1,0,0,0,0,1,0,0,0,0,0,1,0,1,0,0,0,1,1,0,1,1,0,0,1,1,0,1,0,1,0,0,1,0,0,1,1,1,0,1,0,1,0,1,0,1,0,1,0,1,1,1,1,1,1,0,0,1,0,1]]],IndexVal 0], start_saturated = False}";
      int reported = 0;
      arg1[0] = 8825627919024314304;
      arg1[1] = 3170729732334239576;
      arg1[2] = 1849482927839856364;
      arg1[3] = -8927119761593753263;
      arg2.val[0] = vcreate_p64(UINT64_C(0x0374f1ed6e5566ff));
      arg2.val[1] = vcreate_p64(UINT64_C(0xa94c7c0637f1ee86));
      arg2.val[2] = vcreate_p64(UINT64_C(0xff726bc3cb0760b6));
      arg2.val[3] = vcreate_p64(UINT64_C(0xa7eaab92b3628219));
      clear_neon_saturated();
      //  Expect: "result" = 841c7fdfeed5a15119aaaeec840b46ec2c00b1e46e8d3f587a7aedd50936d7c0
      result = vld4_lane_p64(arg1, arg2, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_p64(result.val[0]), 0);
         exp = UINT64_C(0x7a7aedd50936d7c0);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_p64(result.val[1]), 0);
         exp = UINT64_C(0x2c00b1e46e8d3f58);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_p64(result.val[2]), 0);
         exp = UINT64_C(0x19aaaeec840b46ec);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 2 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_p64(result.val[3]), 0);
         exp = UINT64_C(0x841c7fdfeed5a151);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 3 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1574() {

{
   {
      uint8x16x2_t arg2;
      uint8_t result[32];
      char* str1 = "ReproInfo2 {semantics = \"store2\", fnname = \"vst2q_u8\", rettype = \"__transfersize(32) uint8_t *\", argtypes = \"[/* result holder */,uint8x16x2_t]\", vals = [PtrVal [],ArrayVal [VectorVal [IntegerVal 127,IntegerVal 255,IntegerVal 127,IntegerVal 0,IntegerVal 128,IntegerVal 127,IntegerVal 127,IntegerVal 255,IntegerVal 0,IntegerVal 127,IntegerVal 33,IntegerVal 128,IntegerVal 0,IntegerVal 255,IntegerVal 0,IntegerVal 0],VectorVal [IntegerVal 128,IntegerVal 127,IntegerVal 255,IntegerVal 128,IntegerVal 255,IntegerVal 255,IntegerVal 255,IntegerVal 127,IntegerVal 83,IntegerVal 4,IntegerVal 0,IntegerVal 255,IntegerVal 180,IntegerVal 128,IntegerVal 128,IntegerVal 127]]], start_saturated = False}";
      int reported = 0;
      arg2.val[0] = vcombine_u8(vcreate_u8(UINT64_C(0xff7f7f80007fff7f)),
                                vcreate_u8(UINT64_C(0x0000ff0080217f00)));
      arg2.val[1] = vcombine_u8(vcreate_u8(UINT64_C(0x7fffffff80ff7f80)),
                                vcreate_u8(UINT64_C(0x7f8080b4ff000453)));
      clear_neon_saturated();
      vst2q_u8(result, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint8_t got;
         uint8_t exp;
         got = result[0];
         exp = 127U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 0 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[1];
         exp = 128U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 1 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[2];
         exp = 255U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 2 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[3];
         exp = 127U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 3 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[4];
         exp = 127U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 4 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[5];
         exp = 255U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 5 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[6];
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 6 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[7];
         exp = 128U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 7 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[8];
         exp = 128U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 8 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[9];
         exp = 255U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 9 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[10];
         exp = 127U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 10 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[11];
         exp = 255U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 11 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[12];
         exp = 127U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 12 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[13];
         exp = 255U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 13 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[14];
         exp = 255U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 14 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[15];
         exp = 127U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 15 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[16];
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 16 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[17];
         exp = 83U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 17 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[18];
         exp = 127U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 18 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[19];
         exp = 4U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 19 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[20];
         exp = 33U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 20 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[21];
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 21 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[22];
         exp = 128U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 22 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[23];
         exp = 255U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 23 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[24];
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 24 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[25];
         exp = 180U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 25 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[26];
         exp = 255U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 26 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[27];
         exp = 128U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 27 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[28];
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 28 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[29];
         exp = 128U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 29 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[30];
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 30 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[31];
         exp = 127U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 31 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1575() {

{
   {
      uint16x8x2_t arg2;
      uint16_t result[16];
      char* str1 = "ReproInfo2 {semantics = \"store2\", fnname = \"vst2q_u16\", rettype = \"__transfersize(16) uint16_t *\", argtypes = \"[/* result holder */,uint16x8x2_t]\", vals = [PtrVal [],ArrayVal [VectorVal [IntegerVal 32767,IntegerVal 32768,IntegerVal 15580,IntegerVal 65535,IntegerVal 32768,IntegerVal 32767,IntegerVal 0,IntegerVal 32768],VectorVal [IntegerVal 65535,IntegerVal 32767,IntegerVal 0,IntegerVal 65535,IntegerVal 0,IntegerVal 65535,IntegerVal 0,IntegerVal 32767]]], start_saturated = False}";
      int reported = 0;
      arg2.val[0] = vcombine_u16(vcreate_u16(UINT64_C(0xffff3cdc80007fff)),
                                 vcreate_u16(UINT64_C(0x800000007fff8000)));
      arg2.val[1] = vcombine_u16(vcreate_u16(UINT64_C(0xffff00007fffffff)),
                                 vcreate_u16(UINT64_C(0x7fff0000ffff0000)));
      clear_neon_saturated();
      vst2q_u16(result, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint16_t got;
         uint16_t exp;
         got = result[0];
         exp = 32767U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 0 ",
                      exp,
                      got);
            }
      }
      {
         uint16_t got;
         uint16_t exp;
         got = result[1];
         exp = 65535U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 1 ",
                      exp,
                      got);
            }
      }
      {
         uint16_t got;
         uint16_t exp;
         got = result[2];
         exp = 32768U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 2 ",
                      exp,
                      got);
            }
      }
      {
         uint16_t got;
         uint16_t exp;
         got = result[3];
         exp = 32767U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 3 ",
                      exp,
                      got);
            }
      }
      {
         uint16_t got;
         uint16_t exp;
         got = result[4];
         exp = 15580U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 4 ",
                      exp,
                      got);
            }
      }
      {
         uint16_t got;
         uint16_t exp;
         got = result[5];
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 5 ",
                      exp,
                      got);
            }
      }
      {
         uint16_t got;
         uint16_t exp;
         got = result[6];
         exp = 65535U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 6 ",
                      exp,
                      got);
            }
      }
      {
         uint16_t got;
         uint16_t exp;
         got = result[7];
         exp = 65535U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 7 ",
                      exp,
                      got);
            }
      }
      {
         uint16_t got;
         uint16_t exp;
         got = result[8];
         exp = 32768U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 8 ",
                      exp,
                      got);
            }
      }
      {
         uint16_t got;
         uint16_t exp;
         got = result[9];
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 9 ",
                      exp,
                      got);
            }
      }
      {
         uint16_t got;
         uint16_t exp;
         got = result[10];
         exp = 32767U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 10 ",
                      exp,
                      got);
            }
      }
      {
         uint16_t got;
         uint16_t exp;
         got = result[11];
         exp = 65535U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 11 ",
                      exp,
                      got);
            }
      }
      {
         uint16_t got;
         uint16_t exp;
         got = result[12];
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 12 ",
                      exp,
                      got);
            }
      }
      {
         uint16_t got;
         uint16_t exp;
         got = result[13];
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 13 ",
                      exp,
                      got);
            }
      }
      {
         uint16_t got;
         uint16_t exp;
         got = result[14];
         exp = 32768U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 14 ",
                      exp,
                      got);
            }
      }
      {
         uint16_t got;
         uint16_t exp;
         got = result[15];
         exp = 32767U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 15 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1576() {

{
   {
      uint32x4x2_t arg2;
      uint32_t result[8];
      char* str1 = "ReproInfo2 {semantics = \"store2\", fnname = \"vst2q_u32\", rettype = \"__transfersize(8) uint32_t *\", argtypes = \"[/* result holder */,uint32x4x2_t]\", vals = [PtrVal [],ArrayVal [VectorVal [IntegerVal 2147483648,IntegerVal 4294933053,IntegerVal 3972857856,IntegerVal 4294934527],VectorVal [IntegerVal 2147516415,IntegerVal 2147521326,IntegerVal 3630286127,IntegerVal 4294901760]]], start_saturated = False}";
      int reported = 0;
      arg2.val[0] = vcombine_u32(vcreate_u32(UINT64_C(0xffff7a3d80000000)),
                                 vcreate_u32(UINT64_C(0xffff7fffeccd0000)));
      arg2.val[1] = vcombine_u32(vcreate_u32(UINT64_C(0x8000932e80007fff)),
                                 vcreate_u32(UINT64_C(0xffff0000d861c52f)));
      clear_neon_saturated();
      vst2q_u32(result, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint32_t got;
         uint32_t exp;
         got = result[0];
         exp = 2147483648U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu32 " Got: %" PRIu32 "\n",
                      "   Elem 0 ",
                      exp,
                      got);
            }
      }
      {
         uint32_t got;
         uint32_t exp;
         got = result[1];
         exp = 2147516415U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu32 " Got: %" PRIu32 "\n",
                      "   Elem 1 ",
                      exp,
                      got);
            }
      }
      {
         uint32_t got;
         uint32_t exp;
         got = result[2];
         exp = 4294933053U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu32 " Got: %" PRIu32 "\n",
                      "   Elem 2 ",
                      exp,
                      got);
            }
      }
      {
         uint32_t got;
         uint32_t exp;
         got = result[3];
         exp = 2147521326U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu32 " Got: %" PRIu32 "\n",
                      "   Elem 3 ",
                      exp,
                      got);
            }
      }
      {
         uint32_t got;
         uint32_t exp;
         got = result[4];
         exp = 3972857856U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu32 " Got: %" PRIu32 "\n",
                      "   Elem 4 ",
                      exp,
                      got);
            }
      }
      {
         uint32_t got;
         uint32_t exp;
         got = result[5];
         exp = 3630286127U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu32 " Got: %" PRIu32 "\n",
                      "   Elem 5 ",
                      exp,
                      got);
            }
      }
      {
         uint32_t got;
         uint32_t exp;
         got = result[6];
         exp = 4294934527U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu32 " Got: %" PRIu32 "\n",
                      "   Elem 6 ",
                      exp,
                      got);
            }
      }
      {
         uint32_t got;
         uint32_t exp;
         got = result[7];
         exp = 4294901760U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu32 " Got: %" PRIu32 "\n",
                      "   Elem 7 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1577() {

{
   {
      uint64x2x2_t arg2;
      uint64_t result[4];
      char* str1 = "ReproInfo2 {semantics = \"store2\", fnname = \"vst2q_u64\", rettype = \"__transfersize(4) uint64_t *\", argtypes = \"[/* result holder */,uint64x2x2_t]\", vals = [PtrVal [],ArrayVal [VectorVal [IntegerVal 9223512776490614783,IntegerVal 9223512774343163904],VectorVal [IntegerVal 11283330197744451584,IntegerVal 10336324094768734298]]], start_saturated = False}";
      int reported = 0;
      arg2.val[0] = vcombine_u64(vcreate_u64(UINT64_C(0x800080007fffffff)),
                                 vcreate_u64(UINT64_C(0x8000800000008000)));
      arg2.val[1] = vcombine_u64(vcreate_u64(UINT64_C(0x9c9671087fff0000)),
                                 vcreate_u64(UINT64_C(0x8f7200000000605a)));
      clear_neon_saturated();
      vst2q_u64(result, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = result[0];
         exp = UINT64_C(0x800080007fffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Elem 0 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = result[1];
         exp = UINT64_C(0x9c9671087fff0000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Elem 1 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = result[2];
         exp = UINT64_C(0x8000800000008000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Elem 2 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = result[3];
         exp = UINT64_C(0x8f7200000000605a);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Elem 3 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1578() {

{
   {
      int8x16x2_t arg2;
      int8_t result[32];
      char* str1 = "ReproInfo2 {semantics = \"store2\", fnname = \"vst2q_s8\", rettype = \"__transfersize(32) int8_t *\", argtypes = \"[/* result holder */,int8x16x2_t]\", vals = [PtrVal [],ArrayVal [VectorVal [IntegerVal 0,IntegerVal (-128),IntegerVal 127,IntegerVal 0,IntegerVal 127,IntegerVal (-82),IntegerVal 0,IntegerVal (-1),IntegerVal 91,IntegerVal (-1),IntegerVal 100,IntegerVal 15,IntegerVal (-128),IntegerVal (-1),IntegerVal 0,IntegerVal 127],VectorVal [IntegerVal (-1),IntegerVal 0,IntegerVal 0,IntegerVal (-128),IntegerVal 0,IntegerVal (-1),IntegerVal 0,IntegerVal 127,IntegerVal (-128),IntegerVal (-44),IntegerVal (-1),IntegerVal 95,IntegerVal 0,IntegerVal 127,IntegerVal (-128),IntegerVal 108]]], start_saturated = False}";
      int reported = 0;
      arg2.val[0] = vcombine_s8(vcreate_s8(UINT64_C(0xff00ae7f007f8000)),
                                vcreate_s8(UINT64_C(0x7f00ff800f64ff5b)));
      arg2.val[1] = vcombine_s8(vcreate_s8(UINT64_C(0x7f00ff00800000ff)),
                                vcreate_s8(UINT64_C(0x6c807f005fffd480)));
      clear_neon_saturated();
      vst2q_s8(result, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         int8_t got;
         int8_t exp;
         got = result[0];
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 0 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[1];
         exp = -1;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 1 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[2];
         exp = -128;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 2 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[3];
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 3 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[4];
         exp = 127;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 4 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[5];
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 5 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[6];
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 6 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[7];
         exp = -128;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 7 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[8];
         exp = 127;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 8 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[9];
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 9 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[10];
         exp = -82;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 10 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[11];
         exp = -1;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 11 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[12];
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 12 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[13];
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 13 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[14];
         exp = -1;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 14 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[15];
         exp = 127;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 15 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[16];
         exp = 91;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 16 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[17];
         exp = -128;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 17 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[18];
         exp = -1;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 18 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[19];
         exp = -44;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 19 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[20];
         exp = 100;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 20 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[21];
         exp = -1;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 21 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[22];
         exp = 15;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 22 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[23];
         exp = 95;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 23 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[24];
         exp = -128;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 24 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[25];
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 25 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[26];
         exp = -1;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 26 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[27];
         exp = 127;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 27 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[28];
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 28 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[29];
         exp = -128;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 29 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[30];
         exp = 127;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 30 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[31];
         exp = 108;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 31 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1579() {

{
   {
      int16x8x2_t arg2;
      int16_t result[16];
      char* str1 = "ReproInfo2 {semantics = \"store2\", fnname = \"vst2q_s16\", rettype = \"__transfersize(16) int16_t *\", argtypes = \"[/* result holder */,int16x8x2_t]\", vals = [PtrVal [],ArrayVal [VectorVal [IntegerVal 32767,IntegerVal (-32768),IntegerVal (-28167),IntegerVal 32767,IntegerVal (-1),IntegerVal 32767,IntegerVal (-1),IntegerVal (-32768)],VectorVal [IntegerVal (-15041),IntegerVal (-12881),IntegerVal (-1),IntegerVal 13989,IntegerVal (-1),IntegerVal 0,IntegerVal 0,IntegerVal 32767]]], start_saturated = False}";
      int reported = 0;
      arg2.val[0] = vcombine_s16(vcreate_s16(UINT64_C(0x7fff91f980007fff)),
                                 vcreate_s16(UINT64_C(0x8000ffff7fffffff)));
      arg2.val[1] = vcombine_s16(vcreate_s16(UINT64_C(0x36a5ffffcdafc53f)),
                                 vcreate_s16(UINT64_C(0x7fff00000000ffff)));
      clear_neon_saturated();
      vst2q_s16(result, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         int16_t got;
         int16_t exp;
         got = result[0];
         exp = 32767;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi16 " Got: %" PRIi16 "\n",
                      "   Elem 0 ",
                      exp,
                      got);
            }
      }
      {
         int16_t got;
         int16_t exp;
         got = result[1];
         exp = -15041;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi16 " Got: %" PRIi16 "\n",
                      "   Elem 1 ",
                      exp,
                      got);
            }
      }
      {
         int16_t got;
         int16_t exp;
         got = result[2];
         exp = -32768;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi16 " Got: %" PRIi16 "\n",
                      "   Elem 2 ",
                      exp,
                      got);
            }
      }
      {
         int16_t got;
         int16_t exp;
         got = result[3];
         exp = -12881;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi16 " Got: %" PRIi16 "\n",
                      "   Elem 3 ",
                      exp,
                      got);
            }
      }
      {
         int16_t got;
         int16_t exp;
         got = result[4];
         exp = -28167;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi16 " Got: %" PRIi16 "\n",
                      "   Elem 4 ",
                      exp,
                      got);
            }
      }
      {
         int16_t got;
         int16_t exp;
         got = result[5];
         exp = -1;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi16 " Got: %" PRIi16 "\n",
                      "   Elem 5 ",
                      exp,
                      got);
            }
      }
      {
         int16_t got;
         int16_t exp;
         got = result[6];
         exp = 32767;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi16 " Got: %" PRIi16 "\n",
                      "   Elem 6 ",
                      exp,
                      got);
            }
      }
      {
         int16_t got;
         int16_t exp;
         got = result[7];
         exp = 13989;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi16 " Got: %" PRIi16 "\n",
                      "   Elem 7 ",
                      exp,
                      got);
            }
      }
      {
         int16_t got;
         int16_t exp;
         got = result[8];
         exp = -1;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi16 " Got: %" PRIi16 "\n",
                      "   Elem 8 ",
                      exp,
                      got);
            }
      }
      {
         int16_t got;
         int16_t exp;
         got = result[9];
         exp = -1;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi16 " Got: %" PRIi16 "\n",
                      "   Elem 9 ",
                      exp,
                      got);
            }
      }
      {
         int16_t got;
         int16_t exp;
         got = result[10];
         exp = 32767;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi16 " Got: %" PRIi16 "\n",
                      "   Elem 10 ",
                      exp,
                      got);
            }
      }
      {
         int16_t got;
         int16_t exp;
         got = result[11];
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi16 " Got: %" PRIi16 "\n",
                      "   Elem 11 ",
                      exp,
                      got);
            }
      }
      {
         int16_t got;
         int16_t exp;
         got = result[12];
         exp = -1;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi16 " Got: %" PRIi16 "\n",
                      "   Elem 12 ",
                      exp,
                      got);
            }
      }
      {
         int16_t got;
         int16_t exp;
         got = result[13];
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi16 " Got: %" PRIi16 "\n",
                      "   Elem 13 ",
                      exp,
                      got);
            }
      }
      {
         int16_t got;
         int16_t exp;
         got = result[14];
         exp = -32768;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi16 " Got: %" PRIi16 "\n",
                      "   Elem 14 ",
                      exp,
                      got);
            }
      }
      {
         int16_t got;
         int16_t exp;
         got = result[15];
         exp = 32767;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi16 " Got: %" PRIi16 "\n",
                      "   Elem 15 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1580() {

{
   {
      int32x4x2_t arg2;
      int32_t result[8];
      char* str1 = "ReproInfo2 {semantics = \"store2\", fnname = \"vst2q_s32\", rettype = \"__transfersize(8) int32_t *\", argtypes = \"[/* result holder */,int32x4x2_t]\", vals = [PtrVal [],ArrayVal [VectorVal [IntegerVal (-2147470385),IntegerVal 606994431,IntegerVal 32768,IntegerVal (-2147450881)],VectorVal [IntegerVal 1985107838,IntegerVal 2147418112,IntegerVal (-1051033600),IntegerVal (-654114816)]]], start_saturated = False}";
      int reported = 0;
      arg2.val[0] = vcombine_s32(vcreate_s32(UINT64_C(0x242dffff800033cf)),
                                 vcreate_s32(UINT64_C(0x80007fff00008000)));
      arg2.val[1] = vcombine_s32(vcreate_s32(UINT64_C(0x7fff00007652577e)),
                                 vcreate_s32(UINT64_C(0xd9030000c15a8000)));
      clear_neon_saturated();
      vst2q_s32(result, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         int32_t got;
         int32_t exp;
         got = result[0];
         exp = -2147470385;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi32 " Got: %" PRIi32 "\n",
                      "   Elem 0 ",
                      exp,
                      got);
            }
      }
      {
         int32_t got;
         int32_t exp;
         got = result[1];
         exp = 1985107838;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi32 " Got: %" PRIi32 "\n",
                      "   Elem 1 ",
                      exp,
                      got);
            }
      }
      {
         int32_t got;
         int32_t exp;
         got = result[2];
         exp = 606994431;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi32 " Got: %" PRIi32 "\n",
                      "   Elem 2 ",
                      exp,
                      got);
            }
      }
      {
         int32_t got;
         int32_t exp;
         got = result[3];
         exp = 2147418112;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi32 " Got: %" PRIi32 "\n",
                      "   Elem 3 ",
                      exp,
                      got);
            }
      }
      {
         int32_t got;
         int32_t exp;
         got = result[4];
         exp = 32768;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi32 " Got: %" PRIi32 "\n",
                      "   Elem 4 ",
                      exp,
                      got);
            }
      }
      {
         int32_t got;
         int32_t exp;
         got = result[5];
         exp = -1051033600;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi32 " Got: %" PRIi32 "\n",
                      "   Elem 5 ",
                      exp,
                      got);
            }
      }
      {
         int32_t got;
         int32_t exp;
         got = result[6];
         exp = -2147450881;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi32 " Got: %" PRIi32 "\n",
                      "   Elem 6 ",
                      exp,
                      got);
            }
      }
      {
         int32_t got;
         int32_t exp;
         got = result[7];
         exp = -654114816;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi32 " Got: %" PRIi32 "\n",
                      "   Elem 7 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1581() {

{
   {
      int64x2x2_t arg2;
      int64_t result[4];
      char* str1 = "ReproInfo2 {semantics = \"store2\", fnname = \"vst2q_s64\", rettype = \"__transfersize(4) int64_t *\", argtypes = \"[/* result holder */,int64x2x2_t]\", vals = [PtrVal [],ArrayVal [VectorVal [IntegerVal (-9223231297219002368),IntegerVal (-9223231299366387712)],VectorVal [IntegerVal 140739635871744,IntegerVal (-9223256093823401985)]]], start_saturated = False}";
      int reported = 0;
      arg2.val[0] = vcombine_s64(vcreate_s64(UINT64_C(0x800080007fff0000)),
                                 vcreate_s64(UINT64_C(0x8000800000008000)));
      arg2.val[1] = vcombine_s64(vcreate_s64(UINT64_C(0x0000800080008000)),
                                 vcreate_s64(UINT64_C(0x800069731732ffff)));
      clear_neon_saturated();
      vst2q_s64(result, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         int64_t got;
         int64_t exp;
         got = result[0];
         exp = INT64_C(-9223231297219002368);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi64 " Got: %" PRIi64 "\n",
                      "   Elem 0 ",
                      exp,
                      got);
            }
      }
      {
         int64_t got;
         int64_t exp;
         got = result[1];
         exp = INT64_C(140739635871744);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi64 " Got: %" PRIi64 "\n",
                      "   Elem 1 ",
                      exp,
                      got);
            }
      }
      {
         int64_t got;
         int64_t exp;
         got = result[2];
         exp = INT64_C(-9223231299366387712);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi64 " Got: %" PRIi64 "\n",
                      "   Elem 2 ",
                      exp,
                      got);
            }
      }
      {
         int64_t got;
         int64_t exp;
         got = result[3];
         exp = INT64_C(-9223256093823401985);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi64 " Got: %" PRIi64 "\n",
                      "   Elem 3 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1582() {

{
   {
      float32x4x2_t arg2;
      float32_t result[8];
      char* str1 = "ReproInfo2 {semantics = \"store2\", fnname = \"vst2q_f32\", rettype = \"__transfersize(8) float32_t *\", argtypes = \"[/* result holder */,float32x4x2_t]\", vals = [PtrVal [],ArrayVal [VectorVal [FloatVal 0.6469915509223938,FloatVal 0.10851359367370605,FloatVal 0.5570957660675049,FloatVal 0.2395765781402588],VectorVal [FloatVal 0.7237181067466736,FloatVal 0.6239173412322998,FloatVal 0.6121729612350464,FloatVal 0.649242639541626]]], start_saturated = False}";
      int reported = 0;
      arg2.val[0] = vcombine_f32(vcreate_f32(UINT64_C(0x3dde3c603f25a13d)),
                                 vcreate_f32(UINT64_C(0x3e7553903f0e9dd4)));
      arg2.val[1] = vcombine_f32(vcreate_f32(UINT64_C(0x3f1fb90c3f394597)),
                                 vcreate_f32(UINT64_C(0x3f2634c43f1cb75e)));
      clear_neon_saturated();
      vst2q_f32(result, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = result[0];
         exp = ((float32_t) 0.6469915509223938);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 0 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = result[1];
         exp = ((float32_t) 0.7237181067466736);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 1 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = result[2];
         exp = ((float32_t) 0.10851359367370605);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 2 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = result[3];
         exp = ((float32_t) 0.6239173412322998);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 3 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = result[4];
         exp = ((float32_t) 0.5570957660675049);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 4 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = result[5];
         exp = ((float32_t) 0.6121729612350464);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 5 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = result[6];
         exp = ((float32_t) 0.2395765781402588);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 6 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = result[7];
         exp = ((float32_t) 0.649242639541626);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 7 ", exp, got);
            }
      }
   }
}
}
void dotests_1583() {

{
   {
      float64x2x2_t arg2;
      float64_t result[4];
      char* str1 = "ReproInfo2 {semantics = \"store2\", fnname = \"vst2q_f64\", rettype = \"__transfersize(4) float64_t *\", argtypes = \"[/* result holder */,float64x2x2_t]\", vals = [PtrVal [],ArrayVal [VectorVal [FloatVal 0.8822150554696567,FloatVal 0.34798396544853527],VectorVal [FloatVal 0.6563312031937295,FloatVal 0.4509010587996941]]], start_saturated = False}";
      int reported = 0;
      arg2.val[0] = vcombine_f64(vcreate_f64(UINT64_C(0x3fec3b1b1168fdf7)),
                                 vcreate_f64(UINT64_C(0x3fd6455e89c8910c)));
      arg2.val[1] = vcombine_f64(vcreate_f64(UINT64_C(0x3fe500aa4ba1f6fb)),
                                 vcreate_f64(UINT64_C(0x3fdcdb901d51b182)));
      clear_neon_saturated();
      vst2q_f64(result, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float64_t got;
         float64_t exp;
         got = result[0];
         exp = 0.8822150554696567;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 0 ", exp, got);
            }
      }
      {
         float64_t got;
         float64_t exp;
         got = result[1];
         exp = 0.6563312031937295;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 1 ", exp, got);
            }
      }
      {
         float64_t got;
         float64_t exp;
         got = result[2];
         exp = 0.34798396544853527;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 2 ", exp, got);
            }
      }
      {
         float64_t got;
         float64_t exp;
         got = result[3];
         exp = 0.4509010587996941;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 3 ", exp, got);
            }
      }
   }
}
}
void dotests_1584() {

{
   {
      poly8x16x2_t arg2;
      poly8_t result[32];
      char* str1 = "ReproInfo2 {semantics = \"store2\", fnname = \"vst2q_p8\", rettype = \"__transfersize(32) poly8_t *\", argtypes = \"[/* result holder */,poly8x16x2_t]\", vals = [PtrVal [],ArrayVal [VectorVal [PolyVal [0,1,0,0,1,1,1,0],PolyVal [0,1,1,1,1,0,1,1],PolyVal [1,1,0,1,1,0,1,1],PolyVal [0,0,1,0,1,0,1,1],PolyVal [0,1,0,0,0,1,1,1],PolyVal [1,0,1,1,0,0,1,1],PolyVal [0,0,0,1,0,0,1,0],PolyVal [0,0,1,1,0,0,1,0],PolyVal [1,0,1,1,1,0,0,1],PolyVal [1,0,0,1,0,0,1,0],PolyVal [0,1,0,0,1,0,0,0],PolyVal [1,0,1,1,1,1,1,1],PolyVal [0,0,0,1,0,1,0,0],PolyVal [0,0,1,1,0,0,1,1],PolyVal [0,1,0,1,0,1,1,1],PolyVal [0,1,1,1,1,0,0,0]],VectorVal [PolyVal [1,1,1,1,1,0,1,1],PolyVal [0,1,1,1,0,1,0,1],PolyVal [1,0,0,1,1,0,1,1],PolyVal [1,0,0,0,1,0,1,0],PolyVal [1,1,1,0,0,0,0,1],PolyVal [1,0,0,1,0,0,0,1],PolyVal [1,0,1,1,0,1,0,0],PolyVal [1,1,1,0,1,1,1,1],PolyVal [0,0,0,1,0,1,1,1],PolyVal [0,1,0,0,1,1,1,0],PolyVal [0,1,0,0,0,1,0,1],PolyVal [0,0,1,1,0,0,1,0],PolyVal [0,1,0,0,0,1,0,0],PolyVal [0,0,0,0,0,1,0,1],PolyVal [0,1,0,1,1,0,0,1],PolyVal [1,0,0,0,1,0,1,0]]]], start_saturated = False}";
      int reported = 0;
      arg2.val[0] = vcombine_p8(vcreate_p8(UINT64_C(0x4c48cde2d4dbde72)),
                                vcreate_p8(UINT64_C(0x1eeacc28fd12499d)));
      arg2.val[1] = vcombine_p8(vcreate_p8(UINT64_C(0xf72d898751d9aedf)),
                                vcreate_p8(UINT64_C(0x519aa0224ca272e8)));
      clear_neon_saturated();
      vst2q_p8(result, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         poly8_t got;
         poly8_t exp;
         got = result[0];
         exp = 114;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 0 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[1];
         exp = 223;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 1 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[2];
         exp = 222;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 2 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[3];
         exp = 174;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 3 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[4];
         exp = 219;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 4 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[5];
         exp = 217;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 5 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[6];
         exp = 212;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 6 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[7];
         exp = 81;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 7 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[8];
         exp = 226;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 8 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[9];
         exp = 135;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 9 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[10];
         exp = 205;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 10 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[11];
         exp = 137;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 11 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[12];
         exp = 72;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 12 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[13];
         exp = 45;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 13 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[14];
         exp = 76;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 14 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[15];
         exp = 247;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 15 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[16];
         exp = 157;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 16 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[17];
         exp = 232;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 17 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[18];
         exp = 73;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 18 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[19];
         exp = 114;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 19 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[20];
         exp = 18;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 20 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[21];
         exp = 162;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 21 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[22];
         exp = 253;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 22 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[23];
         exp = 76;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 23 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[24];
         exp = 40;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 24 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[25];
         exp = 34;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 25 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[26];
         exp = 204;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 26 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[27];
         exp = 160;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 27 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[28];
         exp = 234;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 28 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[29];
         exp = 154;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 29 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[30];
         exp = 30;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 30 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[31];
         exp = 81;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 31 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1585() {

{
   {
      poly16x8x2_t arg2;
      poly16_t result[16];
      char* str1 = "ReproInfo2 {semantics = \"store2\", fnname = \"vst2q_p16\", rettype = \"__transfersize(16) poly16_t *\", argtypes = \"[/* result holder */,poly16x8x2_t]\", vals = [PtrVal [],ArrayVal [VectorVal [PolyVal [0,1,0,0,1,0,1,0,1,1,1,1,0,1,1,0],PolyVal [0,0,1,0,1,0,1,0,1,1,1,1,1,0,1,0],PolyVal [0,0,0,1,0,0,0,1,1,1,0,0,0,0,0,1],PolyVal [1,0,0,0,1,1,1,1,1,0,0,0,1,0,1,1],PolyVal [0,0,0,1,1,1,0,1,1,1,1,0,1,1,1,1],PolyVal [0,0,1,0,1,1,0,0,0,0,0,1,0,1,1,0],PolyVal [0,1,1,0,0,1,0,1,0,1,1,0,1,0,1,1],PolyVal [0,0,0,1,0,1,0,1,1,1,1,1,0,0,0,1]],VectorVal [PolyVal [1,1,1,0,1,1,0,1,0,0,0,1,0,1,0,0],PolyVal [0,0,1,1,1,1,0,0,1,0,0,1,0,0,0,1],PolyVal [0,1,0,0,0,1,1,0,1,1,0,0,0,1,0,1],PolyVal [1,1,0,1,0,0,0,1,1,1,1,1,1,0,0,0],PolyVal [0,1,1,0,0,1,0,1,1,0,0,0,1,1,1,0],PolyVal [0,0,1,1,0,1,0,0,1,1,1,1,1,0,0,1],PolyVal [0,0,1,1,0,1,1,0,0,0,0,0,0,0,0,1],PolyVal [0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,1]]]], start_saturated = True}";
      int reported = 0;
      arg2.val[0] = vcombine_p16(vcreate_p16(UINT64_C(0xd1f183885f546f52)),
                                 vcreate_p16(UINT64_C(0x8fa8d6a66834f7b8)));
      arg2.val[1] = vcombine_p16(vcreate_p16(UINT64_C(0x1f8ba362893c28b7)),
                                 vcreate_p16(UINT64_C(0x8540806c9f2c71a6)));
      set_neon_saturated();
      vst2q_p16(result, arg2);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      {
         poly16_t got;
         poly16_t exp;
         got = result[0];
         exp = 28498;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 0 ",
                      exp,
                      got);
            }
      }
      {
         poly16_t got;
         poly16_t exp;
         got = result[1];
         exp = 10423;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 1 ",
                      exp,
                      got);
            }
      }
      {
         poly16_t got;
         poly16_t exp;
         got = result[2];
         exp = 24404;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 2 ",
                      exp,
                      got);
            }
      }
      {
         poly16_t got;
         poly16_t exp;
         got = result[3];
         exp = 35132;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 3 ",
                      exp,
                      got);
            }
      }
      {
         poly16_t got;
         poly16_t exp;
         got = result[4];
         exp = 33672;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 4 ",
                      exp,
                      got);
            }
      }
      {
         poly16_t got;
         poly16_t exp;
         got = result[5];
         exp = 41826;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 5 ",
                      exp,
                      got);
            }
      }
      {
         poly16_t got;
         poly16_t exp;
         got = result[6];
         exp = 53745;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 6 ",
                      exp,
                      got);
            }
      }
      {
         poly16_t got;
         poly16_t exp;
         got = result[7];
         exp = 8075;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 7 ",
                      exp,
                      got);
            }
      }
      {
         poly16_t got;
         poly16_t exp;
         got = result[8];
         exp = 63416;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 8 ",
                      exp,
                      got);
            }
      }
      {
         poly16_t got;
         poly16_t exp;
         got = result[9];
         exp = 29094;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 9 ",
                      exp,
                      got);
            }
      }
      {
         poly16_t got;
         poly16_t exp;
         got = result[10];
         exp = 26676;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 10 ",
                      exp,
                      got);
            }
      }
      {
         poly16_t got;
         poly16_t exp;
         got = result[11];
         exp = 40748;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 11 ",
                      exp,
                      got);
            }
      }
      {
         poly16_t got;
         poly16_t exp;
         got = result[12];
         exp = 54950;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 12 ",
                      exp,
                      got);
            }
      }
      {
         poly16_t got;
         poly16_t exp;
         got = result[13];
         exp = 32876;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 13 ",
                      exp,
                      got);
            }
      }
      {
         poly16_t got;
         poly16_t exp;
         got = result[14];
         exp = 36776;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 14 ",
                      exp,
                      got);
            }
      }
      {
         poly16_t got;
         poly16_t exp;
         got = result[15];
         exp = 34112;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 15 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1586() {
#if __ARM_NEON_FP16_INTRINSICS

{
   {
      float16x8x2_t arg2;
      __fp16 result[16];
      char* str1 = "ReproInfo2 {semantics = \"store2\", fnname = \"vst2q_f16\", rettype = \"__transfersize(16) __fp16 *\", argtypes = \"[/* result holder */,float16x8x2_t]\", vals = [PtrVal [],ArrayVal [VectorVal [FloatVal (-1.0761189981539783),FloatVal (-0.10996874970443216),FloatVal 1.8599517718185936,FloatVal (-5.673239634022684),FloatVal 9.260029824965383,FloatVal (-1.29051442954718),FloatVal 1.1906591165479607,FloatVal (-8.01058578541619)],VectorVal [FloatVal 2.2981547425324056,FloatVal 8.384337068257558,FloatVal (-8.916135790280633),FloatVal (-4.446194195084054),FloatVal 6.140818445193684,FloatVal 8.781148487562888,FloatVal (-6.525756242179252),FloatVal (-9.302239632280822)]]], start_saturated = True}";
      int reported = 0;
      arg2.val[0] = vcombine_f16(vcreate_f16(UINT64_C(0xc5ac3f70af09bc4d)),
                                 vcreate_f16(UINT64_C(0xc8013cc3bd2948a1)));
      arg2.val[1] = vcombine_f16(vcreate_f16(UINT64_C(0xc472c87548314098)),
                                 vcreate_f16(UINT64_C(0xc8a6c68648634624)));
      set_neon_saturated();
      vst2q_f16(result, arg2);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      {
         __fp16 got;
         __fp16 exp;
         got = result[0];
         exp = -1.0761189981539783;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 0 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = result[1];
         exp = 2.2981547425324056;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 1 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = result[2];
         exp = -0.10996874970443216;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 2 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = result[3];
         exp = 8.384337068257558;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 3 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = result[4];
         exp = 1.8599517718185936;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 4 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = result[5];
         exp = -8.916135790280633;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 5 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = result[6];
         exp = -5.673239634022684;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 6 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = result[7];
         exp = -4.446194195084054;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 7 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = result[8];
         exp = 9.260029824965383;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 8 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = result[9];
         exp = 6.140818445193684;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 9 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = result[10];
         exp = -1.29051442954718;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 10 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = result[11];
         exp = 8.781148487562888;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 11 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = result[12];
         exp = 1.1906591165479607;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 12 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = result[13];
         exp = -6.525756242179252;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 13 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = result[14];
         exp = -8.01058578541619;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 14 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = result[15];
         exp = -9.302239632280822;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 15 ", exp, got);
            }
      }
   }
}
#endif
}
void dotests_1587() {

{
   {
      poly64x2x2_t arg2;
      poly64_t result[4];
      char* str1 = "ReproInfo2 {semantics = \"store2\", fnname = \"vst2q_p64\", rettype = \"__transfersize(4) poly64_t *\", argtypes = \"[/* result holder */,poly64x2x2_t]\", vals = [PtrVal [],ArrayVal [VectorVal [PolyVal [1,0,1,1,1,1,0,1,0,1,0,1,1,1,1,1,0,0,0,0,1,1,0,1,1,1,0,0,1,1,1,0,0,1,0,0,1,0,1,1,1,0,0,1,0,1,0,1,0,0,0,1,1,1,0,0,1,1,1,0,0,0,0,0],PolyVal [1,1,0,0,0,0,1,1,0,0,0,1,0,1,0,1,0,1,0,1,1,0,1,0,1,0,1,1,1,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,0,1,0,1,0,0,0,0,1,1,0,1,1,0,1,0,1,0,0,1]],VectorVal [PolyVal [1,0,0,0,0,1,1,1,1,1,0,0,1,0,0,1,1,0,0,1,1,1,0,1,1,1,0,1,1,1,0,1,0,0,0,1,1,1,0,0,0,0,1,1,0,1,1,0,0,1,0,1,0,0,0,0,0,1,0,1,0,1,1,0],PolyVal [1,1,1,1,0,0,0,0,0,1,1,1,1,0,0,0,0,0,1,1,1,0,0,1,1,0,0,1,1,0,0,1,0,1,1,0,1,0,0,1,1,0,0,0,1,0,0,1,1,1,0,0,1,0,0,1,0,0,0,1,1,1,1,0]]]], start_saturated = False}";
      int reported = 0;
      arg2.val[0] = vcombine_p64(vcreate_p64(UINT64_C(0x0738a9d273b0fabd)),
                                 vcreate_p64(UINT64_C(0x95b0a1485d5aa8c3)));
      arg2.val[1] = vcombine_p64(vcreate_p64(UINT64_C(0x6a0a6c38bbb993e1)),
                                 vcreate_p64(UINT64_C(0x78939196999c1e0f)));
      clear_neon_saturated();
      vst2q_p64(result, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         poly64_t got;
         poly64_t exp;
         got = result[0];
         exp = 520352478310496957;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu64 " Got: %" PRIu64 "\n",
                      "   Elem 0 ",
                      exp,
                      got);
            }
      }
      {
         poly64_t got;
         poly64_t exp;
         got = result[1];
         exp = 7641038708710937569;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu64 " Got: %" PRIu64 "\n",
                      "   Elem 1 ",
                      exp,
                      got);
            }
      }
      {
         poly64_t got;
         poly64_t exp;
         got = result[2];
         exp = -7660445633981273917;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu64 " Got: %" PRIu64 "\n",
                      "   Elem 2 ",
                      exp,
                      got);
            }
      }
      {
         poly64_t got;
         poly64_t exp;
         got = result[3];
         exp = 8688448182136086031;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu64 " Got: %" PRIu64 "\n",
                      "   Elem 3 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1588() {

{
   {
      uint8x8x2_t arg2;
      uint8_t result[16];
      char* str1 = "ReproInfo2 {semantics = \"store2\", fnname = \"vst2_u8\", rettype = \"__transfersize(16) uint8_t *\", argtypes = \"[/* result holder */,uint8x8x2_t]\", vals = [PtrVal [],ArrayVal [VectorVal [IntegerVal 255,IntegerVal 255,IntegerVal 118,IntegerVal 0,IntegerVal 127,IntegerVal 0,IntegerVal 255,IntegerVal 222],VectorVal [IntegerVal 127,IntegerVal 0,IntegerVal 177,IntegerVal 128,IntegerVal 0,IntegerVal 255,IntegerVal 0,IntegerVal 255]]], start_saturated = False}";
      int reported = 0;
      arg2.val[0] = vcreate_u8(UINT64_C(0xdeff007f0076ffff));
      arg2.val[1] = vcreate_u8(UINT64_C(0xff00ff0080b1007f));
      clear_neon_saturated();
      vst2_u8(result, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint8_t got;
         uint8_t exp;
         got = result[0];
         exp = 255U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 0 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[1];
         exp = 127U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 1 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[2];
         exp = 255U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 2 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[3];
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 3 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[4];
         exp = 118U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 4 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[5];
         exp = 177U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 5 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[6];
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 6 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[7];
         exp = 128U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 7 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[8];
         exp = 127U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 8 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[9];
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 9 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[10];
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 10 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[11];
         exp = 255U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 11 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[12];
         exp = 255U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 12 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[13];
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 13 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[14];
         exp = 222U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 14 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[15];
         exp = 255U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 15 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1589() {

{
   {
      uint16x4x2_t arg2;
      uint16_t result[8];
      char* str1 = "ReproInfo2 {semantics = \"store2\", fnname = \"vst2_u16\", rettype = \"__transfersize(8) uint16_t *\", argtypes = \"[/* result holder */,uint16x4x2_t]\", vals = [PtrVal [],ArrayVal [VectorVal [IntegerVal 65535,IntegerVal 0,IntegerVal 32767,IntegerVal 0],VectorVal [IntegerVal 65535,IntegerVal 32767,IntegerVal 0,IntegerVal 46453]]], start_saturated = False}";
      int reported = 0;
      arg2.val[0] = vcreate_u16(UINT64_C(0x00007fff0000ffff));
      arg2.val[1] = vcreate_u16(UINT64_C(0xb57500007fffffff));
      clear_neon_saturated();
      vst2_u16(result, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint16_t got;
         uint16_t exp;
         got = result[0];
         exp = 65535U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 0 ",
                      exp,
                      got);
            }
      }
      {
         uint16_t got;
         uint16_t exp;
         got = result[1];
         exp = 65535U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 1 ",
                      exp,
                      got);
            }
      }
      {
         uint16_t got;
         uint16_t exp;
         got = result[2];
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 2 ",
                      exp,
                      got);
            }
      }
      {
         uint16_t got;
         uint16_t exp;
         got = result[3];
         exp = 32767U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 3 ",
                      exp,
                      got);
            }
      }
      {
         uint16_t got;
         uint16_t exp;
         got = result[4];
         exp = 32767U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 4 ",
                      exp,
                      got);
            }
      }
      {
         uint16_t got;
         uint16_t exp;
         got = result[5];
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 5 ",
                      exp,
                      got);
            }
      }
      {
         uint16_t got;
         uint16_t exp;
         got = result[6];
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 6 ",
                      exp,
                      got);
            }
      }
      {
         uint16_t got;
         uint16_t exp;
         got = result[7];
         exp = 46453U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 7 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1590() {

{
   {
      uint32x2x2_t arg2;
      uint32_t result[4];
      char* str1 = "ReproInfo2 {semantics = \"store2\", fnname = \"vst2_u32\", rettype = \"__transfersize(4) uint32_t *\", argtypes = \"[/* result holder */,uint32x2x2_t]\", vals = [PtrVal [],ArrayVal [VectorVal [IntegerVal 0,IntegerVal 2147418112],VectorVal [IntegerVal 4294937650,IntegerVal 32767]]], start_saturated = False}";
      int reported = 0;
      arg2.val[0] = vcreate_u32(UINT64_C(0x7fff000000000000));
      arg2.val[1] = vcreate_u32(UINT64_C(0x00007fffffff8c32));
      clear_neon_saturated();
      vst2_u32(result, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint32_t got;
         uint32_t exp;
         got = result[0];
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu32 " Got: %" PRIu32 "\n",
                      "   Elem 0 ",
                      exp,
                      got);
            }
      }
      {
         uint32_t got;
         uint32_t exp;
         got = result[1];
         exp = 4294937650U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu32 " Got: %" PRIu32 "\n",
                      "   Elem 1 ",
                      exp,
                      got);
            }
      }
      {
         uint32_t got;
         uint32_t exp;
         got = result[2];
         exp = 2147418112U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu32 " Got: %" PRIu32 "\n",
                      "   Elem 2 ",
                      exp,
                      got);
            }
      }
      {
         uint32_t got;
         uint32_t exp;
         got = result[3];
         exp = 32767U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu32 " Got: %" PRIu32 "\n",
                      "   Elem 3 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1591() {

{
   {
      uint64x1x2_t arg2;
      uint64_t result[2];
      char* str1 = "ReproInfo2 {semantics = \"store2\", fnname = \"vst2_u64\", rettype = \"__transfersize(2) uint64_t *\", argtypes = \"[/* result holder */,uint64x1x2_t]\", vals = [PtrVal [],ArrayVal [VectorVal [IntegerVal 9223231297218968979],VectorVal [IntegerVal 18446603336221229056]]], start_saturated = False}";
      int reported = 0;
      arg2.val[0] = vcreate_u64(UINT64_C(0x7fff7fff80007d93));
      arg2.val[1] = vcreate_u64(UINT64_C(0xffff800000008000));
      clear_neon_saturated();
      vst2_u64(result, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = result[0];
         exp = UINT64_C(0x7fff7fff80007d93);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Elem 0 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = result[1];
         exp = UINT64_C(0xffff800000008000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Elem 1 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1592() {

{
   {
      int8x8x2_t arg2;
      int8_t result[16];
      char* str1 = "ReproInfo2 {semantics = \"store2\", fnname = \"vst2_s8\", rettype = \"__transfersize(16) int8_t *\", argtypes = \"[/* result holder */,int8x8x2_t]\", vals = [PtrVal [],ArrayVal [VectorVal [IntegerVal (-5),IntegerVal (-1),IntegerVal 0,IntegerVal 118,IntegerVal 0,IntegerVal (-128),IntegerVal 127,IntegerVal (-128)],VectorVal [IntegerVal (-1),IntegerVal 127,IntegerVal 127,IntegerVal 127,IntegerVal 25,IntegerVal 110,IntegerVal 127,IntegerVal 91]]], start_saturated = False}";
      int reported = 0;
      arg2.val[0] = vcreate_s8(UINT64_C(0x807f80007600fffb));
      arg2.val[1] = vcreate_s8(UINT64_C(0x5b7f6e197f7f7fff));
      clear_neon_saturated();
      vst2_s8(result, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         int8_t got;
         int8_t exp;
         got = result[0];
         exp = -5;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 0 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[1];
         exp = -1;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 1 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[2];
         exp = -1;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 2 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[3];
         exp = 127;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 3 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[4];
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 4 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[5];
         exp = 127;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 5 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[6];
         exp = 118;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 6 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[7];
         exp = 127;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 7 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[8];
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 8 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[9];
         exp = 25;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 9 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[10];
         exp = -128;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 10 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[11];
         exp = 110;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 11 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[12];
         exp = 127;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 12 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[13];
         exp = 127;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 13 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[14];
         exp = -128;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 14 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[15];
         exp = 91;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 15 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1593() {

{
   {
      int16x4x2_t arg2;
      int16_t result[8];
      char* str1 = "ReproInfo2 {semantics = \"store2\", fnname = \"vst2_s16\", rettype = \"__transfersize(8) int16_t *\", argtypes = \"[/* result holder */,int16x4x2_t]\", vals = [PtrVal [],ArrayVal [VectorVal [IntegerVal (-32768),IntegerVal (-1),IntegerVal (-32768),IntegerVal (-1)],VectorVal [IntegerVal (-13163),IntegerVal (-1),IntegerVal (-1),IntegerVal (-32768)]]], start_saturated = False}";
      int reported = 0;
      arg2.val[0] = vcreate_s16(UINT64_C(0xffff8000ffff8000));
      arg2.val[1] = vcreate_s16(UINT64_C(0x8000ffffffffcc95));
      clear_neon_saturated();
      vst2_s16(result, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         int16_t got;
         int16_t exp;
         got = result[0];
         exp = -32768;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi16 " Got: %" PRIi16 "\n",
                      "   Elem 0 ",
                      exp,
                      got);
            }
      }
      {
         int16_t got;
         int16_t exp;
         got = result[1];
         exp = -13163;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi16 " Got: %" PRIi16 "\n",
                      "   Elem 1 ",
                      exp,
                      got);
            }
      }
      {
         int16_t got;
         int16_t exp;
         got = result[2];
         exp = -1;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi16 " Got: %" PRIi16 "\n",
                      "   Elem 2 ",
                      exp,
                      got);
            }
      }
      {
         int16_t got;
         int16_t exp;
         got = result[3];
         exp = -1;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi16 " Got: %" PRIi16 "\n",
                      "   Elem 3 ",
                      exp,
                      got);
            }
      }
      {
         int16_t got;
         int16_t exp;
         got = result[4];
         exp = -32768;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi16 " Got: %" PRIi16 "\n",
                      "   Elem 4 ",
                      exp,
                      got);
            }
      }
      {
         int16_t got;
         int16_t exp;
         got = result[5];
         exp = -1;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi16 " Got: %" PRIi16 "\n",
                      "   Elem 5 ",
                      exp,
                      got);
            }
      }
      {
         int16_t got;
         int16_t exp;
         got = result[6];
         exp = -1;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi16 " Got: %" PRIi16 "\n",
                      "   Elem 6 ",
                      exp,
                      got);
            }
      }
      {
         int16_t got;
         int16_t exp;
         got = result[7];
         exp = -32768;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi16 " Got: %" PRIi16 "\n",
                      "   Elem 7 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1594() {

{
   {
      int32x2x2_t arg2;
      int32_t result[4];
      char* str1 = "ReproInfo2 {semantics = \"store2\", fnname = \"vst2_s32\", rettype = \"__transfersize(4) int32_t *\", argtypes = \"[/* result holder */,int32x2x2_t]\", vals = [PtrVal [],ArrayVal [VectorVal [IntegerVal 32767,IntegerVal (-2147483648)],VectorVal [IntegerVal (-2147450880),IntegerVal 1388216320]]], start_saturated = False}";
      int reported = 0;
      arg2.val[0] = vcreate_s32(UINT64_C(0x8000000000007fff));
      arg2.val[1] = vcreate_s32(UINT64_C(0x52be800080008000));
      clear_neon_saturated();
      vst2_s32(result, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         int32_t got;
         int32_t exp;
         got = result[0];
         exp = 32767;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi32 " Got: %" PRIi32 "\n",
                      "   Elem 0 ",
                      exp,
                      got);
            }
      }
      {
         int32_t got;
         int32_t exp;
         got = result[1];
         exp = -2147450880;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi32 " Got: %" PRIi32 "\n",
                      "   Elem 1 ",
                      exp,
                      got);
            }
      }
      {
         int32_t got;
         int32_t exp;
         got = result[2];
         exp = (int32_t) 0x80000000;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi32 " Got: %" PRIi32 "\n",
                      "   Elem 2 ",
                      exp,
                      got);
            }
      }
      {
         int32_t got;
         int32_t exp;
         got = result[3];
         exp = 1388216320;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi32 " Got: %" PRIi32 "\n",
                      "   Elem 3 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1595() {

{
   {
      int64x1x2_t arg2;
      int64_t result[2];
      char* str1 = "ReproInfo2 {semantics = \"store2\", fnname = \"vst2_s64\", rettype = \"__transfersize(2) int64_t *\", argtypes = \"[/* result holder */,int64x1x2_t]\", vals = [PtrVal [],ArrayVal [VectorVal [IntegerVal (-9223090564025581568)],VectorVal [IntegerVal 70257075060735]]], start_saturated = False}";
      int reported = 0;
      arg2.val[0] = vcreate_s64(UINT64_C(0x8000ffff7fff8000));
      arg2.val[1] = vcreate_s64(UINT64_C(0x00003fe600007fff));
      clear_neon_saturated();
      vst2_s64(result, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         int64_t got;
         int64_t exp;
         got = result[0];
         exp = INT64_C(-9223090564025581568);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi64 " Got: %" PRIi64 "\n",
                      "   Elem 0 ",
                      exp,
                      got);
            }
      }
      {
         int64_t got;
         int64_t exp;
         got = result[1];
         exp = INT64_C(70257075060735);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi64 " Got: %" PRIi64 "\n",
                      "   Elem 1 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1596() {

{
   {
      float32x2x2_t arg2;
      float32_t result[4];
      char* str1 = "ReproInfo2 {semantics = \"store2\", fnname = \"vst2_f32\", rettype = \"__transfersize(4) float32_t *\", argtypes = \"[/* result holder */,float32x2x2_t]\", vals = [PtrVal [],ArrayVal [VectorVal [FloatVal 0.1751023530960083,FloatVal 0.6222484111785889],VectorVal [FloatVal 0.6690603494644165,FloatVal 3.8512349128723145e-2]]], start_saturated = False}";
      int reported = 0;
      arg2.val[0] = vcreate_f32(UINT64_C(0x3f1f4bac3e334e08));
      arg2.val[1] = vcreate_f32(UINT64_C(0x3d1dbf203f2b478a));
      clear_neon_saturated();
      vst2_f32(result, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = result[0];
         exp = ((float32_t) 0.1751023530960083);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 0 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = result[1];
         exp = ((float32_t) 0.6690603494644165);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 1 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = result[2];
         exp = ((float32_t) 0.6222484111785889);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 2 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = result[3];
         exp = ((float32_t) 3.8512349128723145e-2);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 3 ", exp, got);
            }
      }
   }
}
}
void dotests_1597() {

{
   {
      float64x1x2_t arg2;
      float64_t result[2];
      char* str1 = "ReproInfo2 {semantics = \"store2\", fnname = \"vst2_f64\", rettype = \"__transfersize(2) float64_t *\", argtypes = \"[/* result holder */,float64x1x2_t]\", vals = [PtrVal [],ArrayVal [VectorVal [FloatVal 0.5410438539207746],VectorVal [FloatVal 0.5567042408185668]]], start_saturated = False}";
      int reported = 0;
      arg2.val[0] = vcreate_f64(UINT64_C(0x3fe1503b33495433));
      arg2.val[1] = vcreate_f64(UINT64_C(0x3fe1d085697b8731));
      clear_neon_saturated();
      vst2_f64(result, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float64_t got;
         float64_t exp;
         got = result[0];
         exp = 0.5410438539207746;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 0 ", exp, got);
            }
      }
      {
         float64_t got;
         float64_t exp;
         got = result[1];
         exp = 0.5567042408185668;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 1 ", exp, got);
            }
      }
   }
}
}
void dotests_1598() {

{
   {
      poly8x8x2_t arg2;
      poly8_t result[16];
      char* str1 = "ReproInfo2 {semantics = \"store2\", fnname = \"vst2_p8\", rettype = \"__transfersize(16) poly8_t *\", argtypes = \"[/* result holder */,poly8x8x2_t]\", vals = [PtrVal [],ArrayVal [VectorVal [PolyVal [1,1,1,1,0,1,0,1],PolyVal [0,0,0,0,0,0,0,0],PolyVal [1,1,1,1,0,0,0,0],PolyVal [0,0,1,0,0,1,1,1],PolyVal [0,0,1,1,1,1,1,1],PolyVal [0,0,1,1,1,0,0,0],PolyVal [0,1,0,0,0,1,1,0],PolyVal [0,0,1,1,0,1,0,0]],VectorVal [PolyVal [0,1,0,0,0,0,1,1],PolyVal [0,1,0,0,0,1,1,1],PolyVal [1,1,0,0,1,1,0,1],PolyVal [1,0,1,0,0,1,0,0],PolyVal [0,1,0,0,1,0,0,0],PolyVal [0,0,1,1,0,0,0,0],PolyVal [1,1,1,1,1,0,1,0],PolyVal [1,1,0,1,1,1,1,1]]]], start_saturated = False}";
      int reported = 0;
      arg2.val[0] = vcreate_p8(UINT64_C(0x2c621cfce40f00af));
      arg2.val[1] = vcreate_p8(UINT64_C(0xfb5f0c1225b3e2c2));
      clear_neon_saturated();
      vst2_p8(result, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         poly8_t got;
         poly8_t exp;
         got = result[0];
         exp = 175;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 0 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[1];
         exp = 194;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 1 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[2];
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 2 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[3];
         exp = 226;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 3 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[4];
         exp = 15;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 4 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[5];
         exp = 179;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 5 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[6];
         exp = 228;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 6 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[7];
         exp = 37;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 7 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[8];
         exp = 252;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 8 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[9];
         exp = 18;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 9 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[10];
         exp = 28;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 10 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[11];
         exp = 12;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 11 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[12];
         exp = 98;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 12 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[13];
         exp = 95;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 13 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[14];
         exp = 44;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 14 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[15];
         exp = 251;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 15 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1599() {

{
   {
      poly16x4x2_t arg2;
      poly16_t result[8];
      char* str1 = "ReproInfo2 {semantics = \"store2\", fnname = \"vst2_p16\", rettype = \"__transfersize(8) poly16_t *\", argtypes = \"[/* result holder */,poly16x4x2_t]\", vals = [PtrVal [],ArrayVal [VectorVal [PolyVal [0,0,0,0,0,1,1,0,0,1,1,1,1,1,1,1],PolyVal [1,1,1,0,1,0,0,1,1,0,1,1,1,0,0,1],PolyVal [0,0,1,0,0,0,1,1,1,1,0,1,0,0,0,1],PolyVal [0,0,0,0,1,0,1,0,0,0,0,1,1,0,0,0]],VectorVal [PolyVal [1,1,0,1,1,1,0,1,1,0,0,1,1,1,0,0],PolyVal [0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,1],PolyVal [0,1,1,1,1,0,0,1,1,1,1,1,0,0,0,1],PolyVal [0,1,0,1,1,0,1,0,1,0,0,0,1,0,0,1]]]], start_saturated = False}";
      int reported = 0;
      arg2.val[0] = vcreate_p16(UINT64_C(0x18508bc49d97fe60));
      arg2.val[1] = vcreate_p16(UINT64_C(0x915a8f9ec00439bb));
      clear_neon_saturated();
      vst2_p16(result, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         poly16_t got;
         poly16_t exp;
         got = result[0];
         exp = 65120;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 0 ",
                      exp,
                      got);
            }
      }
      {
         poly16_t got;
         poly16_t exp;
         got = result[1];
         exp = 14779;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 1 ",
                      exp,
                      got);
            }
      }
      {
         poly16_t got;
         poly16_t exp;
         got = result[2];
         exp = 40343;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 2 ",
                      exp,
                      got);
            }
      }
      {
         poly16_t got;
         poly16_t exp;
         got = result[3];
         exp = 49156;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 3 ",
                      exp,
                      got);
            }
      }
      {
         poly16_t got;
         poly16_t exp;
         got = result[4];
         exp = 35780;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 4 ",
                      exp,
                      got);
            }
      }
      {
         poly16_t got;
         poly16_t exp;
         got = result[5];
         exp = 36766;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 5 ",
                      exp,
                      got);
            }
      }
      {
         poly16_t got;
         poly16_t exp;
         got = result[6];
         exp = 6224;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 6 ",
                      exp,
                      got);
            }
      }
      {
         poly16_t got;
         poly16_t exp;
         got = result[7];
         exp = 37210;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 7 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1600() {
#if __ARM_NEON_FP16_INTRINSICS

{
   {
      float16x4x2_t arg2;
      __fp16 result[8];
      char* str1 = "ReproInfo2 {semantics = \"store2\", fnname = \"vst2_f16\", rettype = \"__transfersize(8) __fp16 *\", argtypes = \"[/* result holder */,float16x4x2_t]\", vals = [PtrVal [],ArrayVal [VectorVal [FloatVal 3.6707664884969198,FloatVal 6.356526357388919,FloatVal 2.3659868070519536,FloatVal 3.511832597655715],VectorVal [FloatVal 5.558173313901364,FloatVal 2.0966058032195978,FloatVal 2.8724103509418306,FloatVal (-8.434994767341815)]]], start_saturated = False}";
      int reported = 0;
      arg2.val[0] = vcreate_f16(UINT64_C(0x430640bb465b4357));
      arg2.val[1] = vcreate_f16(UINT64_C(0xc83741be4031458e));
      clear_neon_saturated();
      vst2_f16(result, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         __fp16 got;
         __fp16 exp;
         got = result[0];
         exp = 3.6707664884969198;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 0 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = result[1];
         exp = 5.558173313901364;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 1 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = result[2];
         exp = 6.356526357388919;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 2 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = result[3];
         exp = 2.0966058032195978;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 3 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = result[4];
         exp = 2.3659868070519536;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 4 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = result[5];
         exp = 2.8724103509418306;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 5 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = result[6];
         exp = 3.511832597655715;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 6 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = result[7];
         exp = -8.434994767341815;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 7 ", exp, got);
            }
      }
   }
}
#endif
}
void dotests_1601() {

{
   {
      poly64x1x2_t arg2;
      poly64_t result[2];
      char* str1 = "ReproInfo2 {semantics = \"store2\", fnname = \"vst2_p64\", rettype = \"__transfersize(2) poly64_t *\", argtypes = \"[/* result holder */,poly64x1x2_t]\", vals = [PtrVal [],ArrayVal [VectorVal [PolyVal [1,1,1,0,0,1,0,0,0,0,1,1,1,1,0,1,1,0,1,1,1,1,1,0,1,1,1,0,0,1,0,0,0,0,0,0,1,1,0,1,1,1,0,0,1,0,0,1,1,0,0,1,0,1,1,1,0,0,1,0,1,1,1,0]],VectorVal [PolyVal [0,0,0,0,1,1,0,0,1,0,0,0,1,0,0,1,0,0,0,0,1,0,0,1,1,0,0,0,1,1,1,1,0,0,1,1,0,0,0,0,0,0,1,0,1,0,0,0,0,1,1,0,1,1,1,1,0,1,1,0,0,0,1,1]]]], start_saturated = False}";
      int reported = 0;
      arg2.val[0] = vcreate_p64(UINT64_C(0x74e993b0277dbc27));
      arg2.val[1] = vcreate_p64(UINT64_C(0xc6f6140cf1909130));
      clear_neon_saturated();
      vst2_p64(result, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         poly64_t got;
         poly64_t exp;
         got = result[0];
         exp = 8424426962759302183;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu64 " Got: %" PRIu64 "\n",
                      "   Elem 0 ",
                      exp,
                      got);
            }
      }
      {
         poly64_t got;
         poly64_t exp;
         got = result[1];
         exp = -4110075564104052432;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu64 " Got: %" PRIu64 "\n",
                      "   Elem 1 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1602() {

{
   {
      uint8x16x3_t arg2;
      uint8_t result[48];
      char* str1 = "ReproInfo2 {semantics = \"store3\", fnname = \"vst3q_u8\", rettype = \"__transfersize(48) uint8_t *\", argtypes = \"[/* result holder */,uint8x16x3_t]\", vals = [PtrVal [],ArrayVal [VectorVal [IntegerVal 128,IntegerVal 78,IntegerVal 0,IntegerVal 121,IntegerVal 175,IntegerVal 195,IntegerVal 0,IntegerVal 127,IntegerVal 128,IntegerVal 0,IntegerVal 222,IntegerVal 0,IntegerVal 34,IntegerVal 127,IntegerVal 0,IntegerVal 128],VectorVal [IntegerVal 127,IntegerVal 98,IntegerVal 96,IntegerVal 79,IntegerVal 0,IntegerVal 0,IntegerVal 127,IntegerVal 0,IntegerVal 255,IntegerVal 127,IntegerVal 130,IntegerVal 128,IntegerVal 127,IntegerVal 128,IntegerVal 127,IntegerVal 173],VectorVal [IntegerVal 128,IntegerVal 255,IntegerVal 127,IntegerVal 0,IntegerVal 127,IntegerVal 0,IntegerVal 0,IntegerVal 127,IntegerVal 255,IntegerVal 0,IntegerVal 127,IntegerVal 127,IntegerVal 74,IntegerVal 127,IntegerVal 128,IntegerVal 128]]], start_saturated = False}";
      int reported = 0;
      arg2.val[0] = vcombine_u8(vcreate_u8(UINT64_C(0x7f00c3af79004e80)),
                                vcreate_u8(UINT64_C(0x80007f2200de0080)));
      arg2.val[1] = vcombine_u8(vcreate_u8(UINT64_C(0x007f00004f60627f)),
                                vcreate_u8(UINT64_C(0xad7f807f80827fff)));
      arg2.val[2] = vcombine_u8(vcreate_u8(UINT64_C(0x7f00007f007fff80)),
                                vcreate_u8(UINT64_C(0x80807f4a7f7f00ff)));
      clear_neon_saturated();
      vst3q_u8(result, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint8_t got;
         uint8_t exp;
         got = result[0];
         exp = 128U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 0 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[1];
         exp = 127U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 1 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[2];
         exp = 128U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 2 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[3];
         exp = 78U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 3 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[4];
         exp = 98U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 4 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[5];
         exp = 255U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 5 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[6];
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 6 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[7];
         exp = 96U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 7 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[8];
         exp = 127U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 8 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[9];
         exp = 121U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 9 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[10];
         exp = 79U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 10 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[11];
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 11 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[12];
         exp = 175U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 12 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[13];
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 13 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[14];
         exp = 127U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 14 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[15];
         exp = 195U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 15 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[16];
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 16 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[17];
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 17 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[18];
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 18 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[19];
         exp = 127U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 19 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[20];
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 20 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[21];
         exp = 127U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 21 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[22];
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 22 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[23];
         exp = 127U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 23 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[24];
         exp = 128U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 24 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[25];
         exp = 255U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 25 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[26];
         exp = 255U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 26 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[27];
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 27 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[28];
         exp = 127U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 28 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[29];
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 29 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[30];
         exp = 222U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 30 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[31];
         exp = 130U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 31 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[32];
         exp = 127U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 32 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[33];
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 33 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[34];
         exp = 128U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 34 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[35];
         exp = 127U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 35 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[36];
         exp = 34U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 36 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[37];
         exp = 127U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 37 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[38];
         exp = 74U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 38 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[39];
         exp = 127U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 39 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[40];
         exp = 128U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 40 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[41];
         exp = 127U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 41 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[42];
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 42 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[43];
         exp = 127U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 43 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[44];
         exp = 128U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 44 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[45];
         exp = 128U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 45 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[46];
         exp = 173U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 46 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[47];
         exp = 128U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 47 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1603() {

{
   {
      uint16x8x3_t arg2;
      uint16_t result[24];
      char* str1 = "ReproInfo2 {semantics = \"store3\", fnname = \"vst3q_u16\", rettype = \"__transfersize(24) uint16_t *\", argtypes = \"[/* result holder */,uint16x8x3_t]\", vals = [PtrVal [],ArrayVal [VectorVal [IntegerVal 32767,IntegerVal 65535,IntegerVal 32768,IntegerVal 32767,IntegerVal 0,IntegerVal 32768,IntegerVal 32767,IntegerVal 15882],VectorVal [IntegerVal 32767,IntegerVal 32767,IntegerVal 59242,IntegerVal 32768,IntegerVal 32767,IntegerVal 65535,IntegerVal 32767,IntegerVal 2997],VectorVal [IntegerVal 20733,IntegerVal 32767,IntegerVal 0,IntegerVal 32767,IntegerVal 32767,IntegerVal 32768,IntegerVal 65535,IntegerVal 65535]]], start_saturated = False}";
      int reported = 0;
      arg2.val[0] = vcombine_u16(vcreate_u16(UINT64_C(0x7fff8000ffff7fff)),
                                 vcreate_u16(UINT64_C(0x3e0a7fff80000000)));
      arg2.val[1] = vcombine_u16(vcreate_u16(UINT64_C(0x8000e76a7fff7fff)),
                                 vcreate_u16(UINT64_C(0x0bb57fffffff7fff)));
      arg2.val[2] = vcombine_u16(vcreate_u16(UINT64_C(0x7fff00007fff50fd)),
                                 vcreate_u16(UINT64_C(0xffffffff80007fff)));
      clear_neon_saturated();
      vst3q_u16(result, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint16_t got;
         uint16_t exp;
         got = result[0];
         exp = 32767U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 0 ",
                      exp,
                      got);
            }
      }
      {
         uint16_t got;
         uint16_t exp;
         got = result[1];
         exp = 32767U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 1 ",
                      exp,
                      got);
            }
      }
      {
         uint16_t got;
         uint16_t exp;
         got = result[2];
         exp = 20733U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 2 ",
                      exp,
                      got);
            }
      }
      {
         uint16_t got;
         uint16_t exp;
         got = result[3];
         exp = 65535U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 3 ",
                      exp,
                      got);
            }
      }
      {
         uint16_t got;
         uint16_t exp;
         got = result[4];
         exp = 32767U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 4 ",
                      exp,
                      got);
            }
      }
      {
         uint16_t got;
         uint16_t exp;
         got = result[5];
         exp = 32767U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 5 ",
                      exp,
                      got);
            }
      }
      {
         uint16_t got;
         uint16_t exp;
         got = result[6];
         exp = 32768U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 6 ",
                      exp,
                      got);
            }
      }
      {
         uint16_t got;
         uint16_t exp;
         got = result[7];
         exp = 59242U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 7 ",
                      exp,
                      got);
            }
      }
      {
         uint16_t got;
         uint16_t exp;
         got = result[8];
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 8 ",
                      exp,
                      got);
            }
      }
      {
         uint16_t got;
         uint16_t exp;
         got = result[9];
         exp = 32767U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 9 ",
                      exp,
                      got);
            }
      }
      {
         uint16_t got;
         uint16_t exp;
         got = result[10];
         exp = 32768U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 10 ",
                      exp,
                      got);
            }
      }
      {
         uint16_t got;
         uint16_t exp;
         got = result[11];
         exp = 32767U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 11 ",
                      exp,
                      got);
            }
      }
      {
         uint16_t got;
         uint16_t exp;
         got = result[12];
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 12 ",
                      exp,
                      got);
            }
      }
      {
         uint16_t got;
         uint16_t exp;
         got = result[13];
         exp = 32767U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 13 ",
                      exp,
                      got);
            }
      }
      {
         uint16_t got;
         uint16_t exp;
         got = result[14];
         exp = 32767U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 14 ",
                      exp,
                      got);
            }
      }
      {
         uint16_t got;
         uint16_t exp;
         got = result[15];
         exp = 32768U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 15 ",
                      exp,
                      got);
            }
      }
      {
         uint16_t got;
         uint16_t exp;
         got = result[16];
         exp = 65535U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 16 ",
                      exp,
                      got);
            }
      }
      {
         uint16_t got;
         uint16_t exp;
         got = result[17];
         exp = 32768U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 17 ",
                      exp,
                      got);
            }
      }
      {
         uint16_t got;
         uint16_t exp;
         got = result[18];
         exp = 32767U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 18 ",
                      exp,
                      got);
            }
      }
      {
         uint16_t got;
         uint16_t exp;
         got = result[19];
         exp = 32767U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 19 ",
                      exp,
                      got);
            }
      }
      {
         uint16_t got;
         uint16_t exp;
         got = result[20];
         exp = 65535U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 20 ",
                      exp,
                      got);
            }
      }
      {
         uint16_t got;
         uint16_t exp;
         got = result[21];
         exp = 15882U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 21 ",
                      exp,
                      got);
            }
      }
      {
         uint16_t got;
         uint16_t exp;
         got = result[22];
         exp = 2997U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 22 ",
                      exp,
                      got);
            }
      }
      {
         uint16_t got;
         uint16_t exp;
         got = result[23];
         exp = 65535U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 23 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1604() {

{
   {
      uint32x4x3_t arg2;
      uint32_t result[12];
      char* str1 = "ReproInfo2 {semantics = \"store3\", fnname = \"vst3q_u32\", rettype = \"__transfersize(12) uint32_t *\", argtypes = \"[/* result holder */,uint32x4x3_t]\", vals = [PtrVal [],ArrayVal [VectorVal [IntegerVal 2147516415,IntegerVal 32767,IntegerVal 4294934527,IntegerVal 2147483647],VectorVal [IntegerVal 32767,IntegerVal 2147450879,IntegerVal 4294967295,IntegerVal 2147483647],VectorVal [IntegerVal 2147483647,IntegerVal 2147505662,IntegerVal 434962432,IntegerVal 65535]]], start_saturated = True}";
      int reported = 0;
      arg2.val[0] = vcombine_u32(vcreate_u32(UINT64_C(0x00007fff80007fff)),
                                 vcreate_u32(UINT64_C(0x7fffffffffff7fff)));
      arg2.val[1] = vcombine_u32(vcreate_u32(UINT64_C(0x7fff7fff00007fff)),
                                 vcreate_u32(UINT64_C(0x7fffffffffffffff)));
      arg2.val[2] = vcombine_u32(vcreate_u32(UINT64_C(0x800055fe7fffffff)),
                                 vcreate_u32(UINT64_C(0x0000ffff19ed0000)));
      set_neon_saturated();
      vst3q_u32(result, arg2);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      {
         uint32_t got;
         uint32_t exp;
         got = result[0];
         exp = 2147516415U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu32 " Got: %" PRIu32 "\n",
                      "   Elem 0 ",
                      exp,
                      got);
            }
      }
      {
         uint32_t got;
         uint32_t exp;
         got = result[1];
         exp = 32767U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu32 " Got: %" PRIu32 "\n",
                      "   Elem 1 ",
                      exp,
                      got);
            }
      }
      {
         uint32_t got;
         uint32_t exp;
         got = result[2];
         exp = 2147483647U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu32 " Got: %" PRIu32 "\n",
                      "   Elem 2 ",
                      exp,
                      got);
            }
      }
      {
         uint32_t got;
         uint32_t exp;
         got = result[3];
         exp = 32767U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu32 " Got: %" PRIu32 "\n",
                      "   Elem 3 ",
                      exp,
                      got);
            }
      }
      {
         uint32_t got;
         uint32_t exp;
         got = result[4];
         exp = 2147450879U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu32 " Got: %" PRIu32 "\n",
                      "   Elem 4 ",
                      exp,
                      got);
            }
      }
      {
         uint32_t got;
         uint32_t exp;
         got = result[5];
         exp = 2147505662U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu32 " Got: %" PRIu32 "\n",
                      "   Elem 5 ",
                      exp,
                      got);
            }
      }
      {
         uint32_t got;
         uint32_t exp;
         got = result[6];
         exp = 4294934527U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu32 " Got: %" PRIu32 "\n",
                      "   Elem 6 ",
                      exp,
                      got);
            }
      }
      {
         uint32_t got;
         uint32_t exp;
         got = result[7];
         exp = 4294967295U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu32 " Got: %" PRIu32 "\n",
                      "   Elem 7 ",
                      exp,
                      got);
            }
      }
      {
         uint32_t got;
         uint32_t exp;
         got = result[8];
         exp = 434962432U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu32 " Got: %" PRIu32 "\n",
                      "   Elem 8 ",
                      exp,
                      got);
            }
      }
      {
         uint32_t got;
         uint32_t exp;
         got = result[9];
         exp = 2147483647U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu32 " Got: %" PRIu32 "\n",
                      "   Elem 9 ",
                      exp,
                      got);
            }
      }
      {
         uint32_t got;
         uint32_t exp;
         got = result[10];
         exp = 2147483647U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu32 " Got: %" PRIu32 "\n",
                      "   Elem 10 ",
                      exp,
                      got);
            }
      }
      {
         uint32_t got;
         uint32_t exp;
         got = result[11];
         exp = 65535U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu32 " Got: %" PRIu32 "\n",
                      "   Elem 11 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1605() {

{
   {
      uint64x2x3_t arg2;
      uint64_t result[6];
      char* str1 = "ReproInfo2 {semantics = \"store3\", fnname = \"vst3q_u64\", rettype = \"__transfersize(6) uint64_t *\", argtypes = \"[/* result holder */,uint64x2x3_t]\", vals = [PtrVal [],ArrayVal [VectorVal [IntegerVal 140734084251648,IntegerVal 18446603332624998688],VectorVal [IntegerVal 140735340871680,IntegerVal 12888925703273176718],VectorVal [IntegerVal 4880776094015291391,IntegerVal 9223512772195581952]]], start_saturated = False}";
      int reported = 0;
      arg2.val[0] = vcombine_u64(vcreate_u64(UINT64_C(0x00007fff35198000)),
                                 vcreate_u64(UINT64_C(0xffff7fff29a66120)));
      arg2.val[1] = vcombine_u64(vcreate_u64(UINT64_C(0x00007fff80000000)),
                                 vcreate_u64(UINT64_C(0xb2dea9a37fffde8e)));
      arg2.val[2] = vcombine_u64(vcreate_u64(UINT64_C(0x43bbffff7fffffff)),
                                 vcreate_u64(UINT64_C(0x80007fff7fff0000)));
      clear_neon_saturated();
      vst3q_u64(result, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = result[0];
         exp = UINT64_C(0x00007fff35198000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Elem 0 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = result[1];
         exp = UINT64_C(0x00007fff80000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Elem 1 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = result[2];
         exp = UINT64_C(0x43bbffff7fffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Elem 2 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = result[3];
         exp = UINT64_C(0xffff7fff29a66120);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Elem 3 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = result[4];
         exp = UINT64_C(0xb2dea9a37fffde8e);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Elem 4 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = result[5];
         exp = UINT64_C(0x80007fff7fff0000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Elem 5 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1606() {

{
   {
      int8x16x3_t arg2;
      int8_t result[48];
      char* str1 = "ReproInfo2 {semantics = \"store3\", fnname = \"vst3q_s8\", rettype = \"__transfersize(48) int8_t *\", argtypes = \"[/* result holder */,int8x16x3_t]\", vals = [PtrVal [],ArrayVal [VectorVal [IntegerVal 0,IntegerVal 61,IntegerVal (-1),IntegerVal (-1),IntegerVal 127,IntegerVal 10,IntegerVal 62,IntegerVal (-8),IntegerVal 110,IntegerVal (-128),IntegerVal 127,IntegerVal 127,IntegerVal (-1),IntegerVal (-128),IntegerVal (-9),IntegerVal 127],VectorVal [IntegerVal (-128),IntegerVal (-1),IntegerVal (-23),IntegerVal 127,IntegerVal 1,IntegerVal (-128),IntegerVal (-96),IntegerVal (-128),IntegerVal (-1),IntegerVal (-1),IntegerVal 0,IntegerVal (-1),IntegerVal 51,IntegerVal (-115),IntegerVal (-1),IntegerVal (-1)],VectorVal [IntegerVal (-78),IntegerVal 0,IntegerVal 127,IntegerVal (-128),IntegerVal (-90),IntegerVal 127,IntegerVal 0,IntegerVal 127,IntegerVal (-1),IntegerVal (-1),IntegerVal (-1),IntegerVal (-128),IntegerVal 109,IntegerVal 0,IntegerVal 0,IntegerVal 0]]], start_saturated = False}";
      int reported = 0;
      arg2.val[0] = vcombine_s8(vcreate_s8(UINT64_C(0xf83e0a7fffff3d00)),
                                vcreate_s8(UINT64_C(0x7ff780ff7f7f806e)));
      arg2.val[1] = vcombine_s8(vcreate_s8(UINT64_C(0x80a080017fe9ff80)),
                                vcreate_s8(UINT64_C(0xffff8d33ff00ffff)));
      arg2.val[2] = vcombine_s8(vcreate_s8(UINT64_C(0x7f007fa6807f00b2)),
                                vcreate_s8(UINT64_C(0x0000006d80ffffff)));
      clear_neon_saturated();
      vst3q_s8(result, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         int8_t got;
         int8_t exp;
         got = result[0];
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 0 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[1];
         exp = -128;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 1 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[2];
         exp = -78;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 2 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[3];
         exp = 61;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 3 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[4];
         exp = -1;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 4 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[5];
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 5 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[6];
         exp = -1;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 6 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[7];
         exp = -23;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 7 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[8];
         exp = 127;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 8 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[9];
         exp = -1;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 9 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[10];
         exp = 127;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 10 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[11];
         exp = -128;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 11 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[12];
         exp = 127;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 12 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[13];
         exp = 1;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 13 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[14];
         exp = -90;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 14 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[15];
         exp = 10;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 15 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[16];
         exp = -128;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 16 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[17];
         exp = 127;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 17 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[18];
         exp = 62;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 18 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[19];
         exp = -96;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 19 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[20];
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 20 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[21];
         exp = -8;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 21 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[22];
         exp = -128;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 22 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[23];
         exp = 127;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 23 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[24];
         exp = 110;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 24 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[25];
         exp = -1;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 25 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[26];
         exp = -1;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 26 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[27];
         exp = -128;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 27 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[28];
         exp = -1;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 28 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[29];
         exp = -1;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 29 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[30];
         exp = 127;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 30 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[31];
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 31 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[32];
         exp = -1;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 32 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[33];
         exp = 127;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 33 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[34];
         exp = -1;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 34 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[35];
         exp = -128;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 35 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[36];
         exp = -1;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 36 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[37];
         exp = 51;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 37 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[38];
         exp = 109;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 38 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[39];
         exp = -128;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 39 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[40];
         exp = -115;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 40 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[41];
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 41 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[42];
         exp = -9;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 42 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[43];
         exp = -1;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 43 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[44];
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 44 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[45];
         exp = 127;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 45 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[46];
         exp = -1;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 46 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[47];
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 47 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1607() {

{
   {
      int16x8x3_t arg2;
      int16_t result[24];
      char* str1 = "ReproInfo2 {semantics = \"store3\", fnname = \"vst3q_s16\", rettype = \"__transfersize(24) int16_t *\", argtypes = \"[/* result holder */,int16x8x3_t]\", vals = [PtrVal [],ArrayVal [VectorVal [IntegerVal 22811,IntegerVal (-32768),IntegerVal 0,IntegerVal 32767,IntegerVal (-1),IntegerVal (-1),IntegerVal 32767,IntegerVal 32767],VectorVal [IntegerVal 32767,IntegerVal (-32768),IntegerVal 0,IntegerVal 32767,IntegerVal (-25295),IntegerVal (-1),IntegerVal 32767,IntegerVal (-24740)],VectorVal [IntegerVal (-32768),IntegerVal 32767,IntegerVal (-32768),IntegerVal (-20026),IntegerVal (-1),IntegerVal (-6965),IntegerVal (-32768),IntegerVal (-1)]]], start_saturated = False}";
      int reported = 0;
      arg2.val[0] = vcombine_s16(vcreate_s16(UINT64_C(0x7fff00008000591b)),
                                 vcreate_s16(UINT64_C(0x7fff7fffffffffff)));
      arg2.val[1] = vcombine_s16(vcreate_s16(UINT64_C(0x7fff000080007fff)),
                                 vcreate_s16(UINT64_C(0x9f5c7fffffff9d31)));
      arg2.val[2] = vcombine_s16(vcreate_s16(UINT64_C(0xb1c680007fff8000)),
                                 vcreate_s16(UINT64_C(0xffff8000e4cbffff)));
      clear_neon_saturated();
      vst3q_s16(result, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         int16_t got;
         int16_t exp;
         got = result[0];
         exp = 22811;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi16 " Got: %" PRIi16 "\n",
                      "   Elem 0 ",
                      exp,
                      got);
            }
      }
      {
         int16_t got;
         int16_t exp;
         got = result[1];
         exp = 32767;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi16 " Got: %" PRIi16 "\n",
                      "   Elem 1 ",
                      exp,
                      got);
            }
      }
      {
         int16_t got;
         int16_t exp;
         got = result[2];
         exp = -32768;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi16 " Got: %" PRIi16 "\n",
                      "   Elem 2 ",
                      exp,
                      got);
            }
      }
      {
         int16_t got;
         int16_t exp;
         got = result[3];
         exp = -32768;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi16 " Got: %" PRIi16 "\n",
                      "   Elem 3 ",
                      exp,
                      got);
            }
      }
      {
         int16_t got;
         int16_t exp;
         got = result[4];
         exp = -32768;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi16 " Got: %" PRIi16 "\n",
                      "   Elem 4 ",
                      exp,
                      got);
            }
      }
      {
         int16_t got;
         int16_t exp;
         got = result[5];
         exp = 32767;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi16 " Got: %" PRIi16 "\n",
                      "   Elem 5 ",
                      exp,
                      got);
            }
      }
      {
         int16_t got;
         int16_t exp;
         got = result[6];
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi16 " Got: %" PRIi16 "\n",
                      "   Elem 6 ",
                      exp,
                      got);
            }
      }
      {
         int16_t got;
         int16_t exp;
         got = result[7];
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi16 " Got: %" PRIi16 "\n",
                      "   Elem 7 ",
                      exp,
                      got);
            }
      }
      {
         int16_t got;
         int16_t exp;
         got = result[8];
         exp = -32768;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi16 " Got: %" PRIi16 "\n",
                      "   Elem 8 ",
                      exp,
                      got);
            }
      }
      {
         int16_t got;
         int16_t exp;
         got = result[9];
         exp = 32767;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi16 " Got: %" PRIi16 "\n",
                      "   Elem 9 ",
                      exp,
                      got);
            }
      }
      {
         int16_t got;
         int16_t exp;
         got = result[10];
         exp = 32767;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi16 " Got: %" PRIi16 "\n",
                      "   Elem 10 ",
                      exp,
                      got);
            }
      }
      {
         int16_t got;
         int16_t exp;
         got = result[11];
         exp = -20026;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi16 " Got: %" PRIi16 "\n",
                      "   Elem 11 ",
                      exp,
                      got);
            }
      }
      {
         int16_t got;
         int16_t exp;
         got = result[12];
         exp = -1;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi16 " Got: %" PRIi16 "\n",
                      "   Elem 12 ",
                      exp,
                      got);
            }
      }
      {
         int16_t got;
         int16_t exp;
         got = result[13];
         exp = -25295;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi16 " Got: %" PRIi16 "\n",
                      "   Elem 13 ",
                      exp,
                      got);
            }
      }
      {
         int16_t got;
         int16_t exp;
         got = result[14];
         exp = -1;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi16 " Got: %" PRIi16 "\n",
                      "   Elem 14 ",
                      exp,
                      got);
            }
      }
      {
         int16_t got;
         int16_t exp;
         got = result[15];
         exp = -1;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi16 " Got: %" PRIi16 "\n",
                      "   Elem 15 ",
                      exp,
                      got);
            }
      }
      {
         int16_t got;
         int16_t exp;
         got = result[16];
         exp = -1;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi16 " Got: %" PRIi16 "\n",
                      "   Elem 16 ",
                      exp,
                      got);
            }
      }
      {
         int16_t got;
         int16_t exp;
         got = result[17];
         exp = -6965;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi16 " Got: %" PRIi16 "\n",
                      "   Elem 17 ",
                      exp,
                      got);
            }
      }
      {
         int16_t got;
         int16_t exp;
         got = result[18];
         exp = 32767;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi16 " Got: %" PRIi16 "\n",
                      "   Elem 18 ",
                      exp,
                      got);
            }
      }
      {
         int16_t got;
         int16_t exp;
         got = result[19];
         exp = 32767;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi16 " Got: %" PRIi16 "\n",
                      "   Elem 19 ",
                      exp,
                      got);
            }
      }
      {
         int16_t got;
         int16_t exp;
         got = result[20];
         exp = -32768;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi16 " Got: %" PRIi16 "\n",
                      "   Elem 20 ",
                      exp,
                      got);
            }
      }
      {
         int16_t got;
         int16_t exp;
         got = result[21];
         exp = 32767;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi16 " Got: %" PRIi16 "\n",
                      "   Elem 21 ",
                      exp,
                      got);
            }
      }
      {
         int16_t got;
         int16_t exp;
         got = result[22];
         exp = -24740;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi16 " Got: %" PRIi16 "\n",
                      "   Elem 22 ",
                      exp,
                      got);
            }
      }
      {
         int16_t got;
         int16_t exp;
         got = result[23];
         exp = -1;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi16 " Got: %" PRIi16 "\n",
                      "   Elem 23 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1608() {

{
   {
      int32x4x3_t arg2;
      int32_t result[12];
      char* str1 = "ReproInfo2 {semantics = \"store3\", fnname = \"vst3q_s32\", rettype = \"__transfersize(12) int32_t *\", argtypes = \"[/* result holder */,int32x4x3_t]\", vals = [PtrVal [],ArrayVal [VectorVal [IntegerVal (-2147450881),IntegerVal (-2147450880),IntegerVal (-1),IntegerVal 2147454442],VectorVal [IntegerVal (-65536),IntegerVal 32768,IntegerVal 32768,IntegerVal 2147450880],VectorVal [IntegerVal (-2147483648),IntegerVal 65535,IntegerVal (-32769),IntegerVal (-2147418113)]]], start_saturated = False}";
      int reported = 0;
      arg2.val[0] = vcombine_s32(vcreate_s32(UINT64_C(0x8000800080007fff)),
                                 vcreate_s32(UINT64_C(0x7fff8deaffffffff)));
      arg2.val[1] = vcombine_s32(vcreate_s32(UINT64_C(0x00008000ffff0000)),
                                 vcreate_s32(UINT64_C(0x7fff800000008000)));
      arg2.val[2] = vcombine_s32(vcreate_s32(UINT64_C(0x0000ffff80000000)),
                                 vcreate_s32(UINT64_C(0x8000ffffffff7fff)));
      clear_neon_saturated();
      vst3q_s32(result, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         int32_t got;
         int32_t exp;
         got = result[0];
         exp = -2147450881;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi32 " Got: %" PRIi32 "\n",
                      "   Elem 0 ",
                      exp,
                      got);
            }
      }
      {
         int32_t got;
         int32_t exp;
         got = result[1];
         exp = -65536;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi32 " Got: %" PRIi32 "\n",
                      "   Elem 1 ",
                      exp,
                      got);
            }
      }
      {
         int32_t got;
         int32_t exp;
         got = result[2];
         exp = (int32_t) 0x80000000;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi32 " Got: %" PRIi32 "\n",
                      "   Elem 2 ",
                      exp,
                      got);
            }
      }
      {
         int32_t got;
         int32_t exp;
         got = result[3];
         exp = -2147450880;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi32 " Got: %" PRIi32 "\n",
                      "   Elem 3 ",
                      exp,
                      got);
            }
      }
      {
         int32_t got;
         int32_t exp;
         got = result[4];
         exp = 32768;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi32 " Got: %" PRIi32 "\n",
                      "   Elem 4 ",
                      exp,
                      got);
            }
      }
      {
         int32_t got;
         int32_t exp;
         got = result[5];
         exp = 65535;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi32 " Got: %" PRIi32 "\n",
                      "   Elem 5 ",
                      exp,
                      got);
            }
      }
      {
         int32_t got;
         int32_t exp;
         got = result[6];
         exp = -1;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi32 " Got: %" PRIi32 "\n",
                      "   Elem 6 ",
                      exp,
                      got);
            }
      }
      {
         int32_t got;
         int32_t exp;
         got = result[7];
         exp = 32768;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi32 " Got: %" PRIi32 "\n",
                      "   Elem 7 ",
                      exp,
                      got);
            }
      }
      {
         int32_t got;
         int32_t exp;
         got = result[8];
         exp = -32769;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi32 " Got: %" PRIi32 "\n",
                      "   Elem 8 ",
                      exp,
                      got);
            }
      }
      {
         int32_t got;
         int32_t exp;
         got = result[9];
         exp = 2147454442;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi32 " Got: %" PRIi32 "\n",
                      "   Elem 9 ",
                      exp,
                      got);
            }
      }
      {
         int32_t got;
         int32_t exp;
         got = result[10];
         exp = 2147450880;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi32 " Got: %" PRIi32 "\n",
                      "   Elem 10 ",
                      exp,
                      got);
            }
      }
      {
         int32_t got;
         int32_t exp;
         got = result[11];
         exp = -2147418113;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi32 " Got: %" PRIi32 "\n",
                      "   Elem 11 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1609() {

{
   {
      int64x2x3_t arg2;
      int64_t result[6];
      char* str1 = "ReproInfo2 {semantics = \"store3\", fnname = \"vst3q_s64\", rettype = \"__transfersize(6) int64_t *\", argtypes = \"[/* result holder */,int64x2x3_t]\", vals = [PtrVal [],ArrayVal [VectorVal [IntegerVal 7812056502969630720,IntegerVal 9223212891136622592],VectorVal [IntegerVal (-4932567494024986624),IntegerVal (-9223372033016332288)],VectorVal [IntegerVal (-9223231299366354945),IntegerVal 140733193453567]]], start_saturated = False}";
      int reported = 0;
      arg2.val[0] = vcombine_s64(vcreate_s64(UINT64_C(0x6c69ffffd8c90000)),
                                 vcreate_s64(UINT64_C(0x7fff6f4200008000)));
      arg2.val[1] = vcombine_s64(vcreate_s64(UINT64_C(0xbb8bffff80008000)),
                                 vcreate_s64(UINT64_C(0x80000000e4ca0000)));
      arg2.val[2] = vcombine_s64(vcreate_s64(UINT64_C(0x800080000000ffff)),
                                 vcreate_s64(UINT64_C(0x00007fff0000ffff)));
      clear_neon_saturated();
      vst3q_s64(result, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         int64_t got;
         int64_t exp;
         got = result[0];
         exp = INT64_C(7812056502969630720);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi64 " Got: %" PRIi64 "\n",
                      "   Elem 0 ",
                      exp,
                      got);
            }
      }
      {
         int64_t got;
         int64_t exp;
         got = result[1];
         exp = INT64_C(-4932567494024986624);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi64 " Got: %" PRIi64 "\n",
                      "   Elem 1 ",
                      exp,
                      got);
            }
      }
      {
         int64_t got;
         int64_t exp;
         got = result[2];
         exp = INT64_C(-9223231299366354945);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi64 " Got: %" PRIi64 "\n",
                      "   Elem 2 ",
                      exp,
                      got);
            }
      }
      {
         int64_t got;
         int64_t exp;
         got = result[3];
         exp = INT64_C(9223212891136622592);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi64 " Got: %" PRIi64 "\n",
                      "   Elem 3 ",
                      exp,
                      got);
            }
      }
      {
         int64_t got;
         int64_t exp;
         got = result[4];
         exp = INT64_C(-9223372033016332288);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi64 " Got: %" PRIi64 "\n",
                      "   Elem 4 ",
                      exp,
                      got);
            }
      }
      {
         int64_t got;
         int64_t exp;
         got = result[5];
         exp = INT64_C(140733193453567);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi64 " Got: %" PRIi64 "\n",
                      "   Elem 5 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1610() {

{
   {
      float32x4x3_t arg2;
      float32_t result[12];
      char* str1 = "ReproInfo2 {semantics = \"store3\", fnname = \"vst3q_f32\", rettype = \"__transfersize(12) float32_t *\", argtypes = \"[/* result holder */,float32x4x3_t]\", vals = [PtrVal [],ArrayVal [VectorVal [FloatVal 0.8308061957359314,FloatVal 4.2467713356018066e-2,FloatVal 0.5019009113311768,FloatVal 0.22053968906402588],VectorVal [FloatVal 0.17725545167922974,FloatVal 0.5766724944114685,FloatVal 9.92194414138794e-2,FloatVal 0.10426652431488037],VectorVal [FloatVal 0.6312085390090942,FloatVal 0.9209582209587097,FloatVal 0.15855401754379272,FloatVal 0.6934713125228882]]], start_saturated = False}";
      int reported = 0;
      arg2.val[0] = vcombine_f32(vcreate_f32(UINT64_C(0x3d2df2a03f54afb7)),
                                 vcreate_f32(UINT64_C(0x3e61d5283f007c94)));
      arg2.val[1] = vcombine_f32(vcreate_f32(UINT64_C(0x3f13a0cf3e358274)),
                                 vcreate_f32(UINT64_C(0x3dd589b03dcb3390)));
      arg2.val[2] = vcombine_f32(vcreate_f32(UINT64_C(0x3f6bc3eb3f2196e2)),
                                 vcreate_f32(UINT64_C(0x3f3187563e225bfc)));
      clear_neon_saturated();
      vst3q_f32(result, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = result[0];
         exp = ((float32_t) 0.8308061957359314);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 0 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = result[1];
         exp = ((float32_t) 0.17725545167922974);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 1 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = result[2];
         exp = ((float32_t) 0.6312085390090942);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 2 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = result[3];
         exp = ((float32_t) 4.2467713356018066e-2);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 3 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = result[4];
         exp = ((float32_t) 0.5766724944114685);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 4 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = result[5];
         exp = ((float32_t) 0.9209582209587097);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 5 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = result[6];
         exp = ((float32_t) 0.5019009113311768);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 6 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = result[7];
         exp = ((float32_t) 9.92194414138794e-2);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 7 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = result[8];
         exp = ((float32_t) 0.15855401754379272);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 8 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = result[9];
         exp = ((float32_t) 0.22053968906402588);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 9 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = result[10];
         exp = ((float32_t) 0.10426652431488037);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 10 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = result[11];
         exp = ((float32_t) 0.6934713125228882);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 11 ", exp, got);
            }
      }
   }
}
}
void dotests_1611() {

{
   {
      float64x2x3_t arg2;
      float64_t result[6];
      char* str1 = "ReproInfo2 {semantics = \"store3\", fnname = \"vst3q_f64\", rettype = \"__transfersize(6) float64_t *\", argtypes = \"[/* result holder */,float64x2x3_t]\", vals = [PtrVal [],ArrayVal [VectorVal [FloatVal 0.6233223090023343,FloatVal 0.18616602492502043],VectorVal [FloatVal 0.47191718406173655,FloatVal 0.492011416127344],VectorVal [FloatVal 0.9691705134502576,FloatVal 0.12883368575856757]]], start_saturated = False}";
      int reported = 0;
      arg2.val[0] = vcombine_f64(vcreate_f64(UINT64_C(0x3fe3f241a081080c)),
                                 vcreate_f64(UINT64_C(0x3fc7d449ce56f2c4)));
      arg2.val[1] = vcombine_f64(vcreate_f64(UINT64_C(0x3fde33e421fdcbea)),
                                 vcreate_f64(UINT64_C(0x3fdf7d1d7361a342)));
      arg2.val[2] = vcombine_f64(vcreate_f64(UINT64_C(0x3fef0371e1708639)),
                                 vcreate_f64(UINT64_C(0x3fc07d9f497a6464)));
      clear_neon_saturated();
      vst3q_f64(result, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float64_t got;
         float64_t exp;
         got = result[0];
         exp = 0.6233223090023343;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 0 ", exp, got);
            }
      }
      {
         float64_t got;
         float64_t exp;
         got = result[1];
         exp = 0.47191718406173655;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 1 ", exp, got);
            }
      }
      {
         float64_t got;
         float64_t exp;
         got = result[2];
         exp = 0.9691705134502576;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 2 ", exp, got);
            }
      }
      {
         float64_t got;
         float64_t exp;
         got = result[3];
         exp = 0.18616602492502043;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 3 ", exp, got);
            }
      }
      {
         float64_t got;
         float64_t exp;
         got = result[4];
         exp = 0.492011416127344;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 4 ", exp, got);
            }
      }
      {
         float64_t got;
         float64_t exp;
         got = result[5];
         exp = 0.12883368575856757;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 5 ", exp, got);
            }
      }
   }
}
}
void dotests_1612() {

{
   {
      poly8x16x3_t arg2;
      poly8_t result[48];
      char* str1 = "ReproInfo2 {semantics = \"store3\", fnname = \"vst3q_p8\", rettype = \"__transfersize(48) poly8_t *\", argtypes = \"[/* result holder */,poly8x16x3_t]\", vals = [PtrVal [],ArrayVal [VectorVal [PolyVal [1,1,0,1,0,1,0,0],PolyVal [1,0,0,1,0,1,0,0],PolyVal [0,0,1,0,1,1,1,0],PolyVal [1,0,0,0,1,0,1,0],PolyVal [0,1,1,0,1,0,0,1],PolyVal [1,0,1,0,1,0,0,1],PolyVal [1,1,0,0,1,1,1,0],PolyVal [0,0,1,1,1,1,1,1],PolyVal [1,1,1,0,1,1,0,0],PolyVal [0,1,1,0,1,1,1,1],PolyVal [1,1,0,1,0,1,0,1],PolyVal [1,0,0,0,0,1,1,0],PolyVal [0,1,0,1,1,1,0,1],PolyVal [0,0,0,0,0,0,1,1],PolyVal [0,0,0,0,0,0,0,1],PolyVal [1,0,1,0,0,1,1,1]],VectorVal [PolyVal [1,1,1,0,0,0,1,0],PolyVal [0,0,0,1,1,0,1,0],PolyVal [0,0,0,0,0,0,1,0],PolyVal [0,1,0,1,0,1,1,0],PolyVal [0,1,1,0,0,1,1,0],PolyVal [0,0,1,1,1,0,0,0],PolyVal [1,0,0,1,1,0,1,1],PolyVal [0,0,1,0,1,1,1,1],PolyVal [0,1,1,0,0,0,1,1],PolyVal [1,0,0,0,1,0,1,1],PolyVal [0,0,1,0,0,1,1,0],PolyVal [0,1,0,1,0,1,0,1],PolyVal [0,1,0,0,1,1,1,1],PolyVal [1,1,1,0,0,1,0,0],PolyVal [0,0,0,0,0,1,1,1],PolyVal [1,1,1,0,1,1,1,1]],VectorVal [PolyVal [1,0,0,1,0,1,1,1],PolyVal [0,0,0,1,1,0,1,1],PolyVal [1,0,0,0,1,0,0,0],PolyVal [0,1,1,0,0,1,1,1],PolyVal [0,1,1,1,1,1,0,0],PolyVal [0,0,1,0,0,1,0,1],PolyVal [0,0,1,1,1,1,0,0],PolyVal [1,1,1,0,1,1,0,0],PolyVal [0,0,0,1,0,0,0,1],PolyVal [1,0,0,1,0,0,0,0],PolyVal [0,1,1,0,0,0,1,1],PolyVal [0,0,0,0,0,1,1,0],PolyVal [0,1,1,1,1,0,1,1],PolyVal [0,0,1,1,0,1,0,0],PolyVal [0,1,0,0,1,1,1,0],PolyVal [0,1,1,1,0,0,1,0]]]], start_saturated = False}";
      int reported = 0;
      arg2.val[0] = vcombine_p8(vcreate_p8(UINT64_C(0xfc7395965174292b)),
                                vcreate_p8(UINT64_C(0xe580c0ba61abf637)));
      arg2.val[1] = vcombine_p8(vcreate_p8(UINT64_C(0xf4d91c666a405847)),
                                vcreate_p8(UINT64_C(0xf7e027f2aa64d1c6)));
      arg2.val[2] = vcombine_p8(vcreate_p8(UINT64_C(0x373ca43ee611d8e9)),
                                vcreate_p8(UINT64_C(0x4e722cde60c60988)));
      clear_neon_saturated();
      vst3q_p8(result, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         poly8_t got;
         poly8_t exp;
         got = result[0];
         exp = 43;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 0 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[1];
         exp = 71;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 1 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[2];
         exp = 233;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 2 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[3];
         exp = 41;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 3 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[4];
         exp = 88;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 4 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[5];
         exp = 216;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 5 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[6];
         exp = 116;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 6 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[7];
         exp = 64;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 7 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[8];
         exp = 17;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 8 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[9];
         exp = 81;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 9 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[10];
         exp = 106;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 10 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[11];
         exp = 230;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 11 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[12];
         exp = 150;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 12 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[13];
         exp = 102;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 13 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[14];
         exp = 62;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 14 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[15];
         exp = 149;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 15 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[16];
         exp = 28;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 16 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[17];
         exp = 164;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 17 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[18];
         exp = 115;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 18 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[19];
         exp = 217;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 19 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[20];
         exp = 60;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 20 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[21];
         exp = 252;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 21 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[22];
         exp = 244;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 22 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[23];
         exp = 55;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 23 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[24];
         exp = 55;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 24 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[25];
         exp = 198;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 25 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[26];
         exp = 136;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 26 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[27];
         exp = 246;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 27 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[28];
         exp = 209;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 28 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[29];
         exp = 9;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 29 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[30];
         exp = 171;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 30 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[31];
         exp = 100;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 31 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[32];
         exp = 198;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 32 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[33];
         exp = 97;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 33 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[34];
         exp = 170;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 34 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[35];
         exp = 96;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 35 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[36];
         exp = 186;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 36 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[37];
         exp = 242;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 37 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[38];
         exp = 222;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 38 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[39];
         exp = 192;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 39 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[40];
         exp = 39;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 40 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[41];
         exp = 44;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 41 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[42];
         exp = 128;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 42 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[43];
         exp = 224;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 43 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[44];
         exp = 114;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 44 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[45];
         exp = 229;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 45 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[46];
         exp = 247;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 46 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[47];
         exp = 78;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 47 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1613() {

{
   {
      poly16x8x3_t arg2;
      poly16_t result[24];
      char* str1 = "ReproInfo2 {semantics = \"store3\", fnname = \"vst3q_p16\", rettype = \"__transfersize(24) poly16_t *\", argtypes = \"[/* result holder */,poly16x8x3_t]\", vals = [PtrVal [],ArrayVal [VectorVal [PolyVal [1,0,0,0,1,1,1,0,1,0,1,0,1,1,1,1],PolyVal [0,1,1,1,1,0,0,0,0,1,1,0,1,1,1,1],PolyVal [1,0,0,1,1,0,1,1,1,1,0,0,0,1,1,0],PolyVal [1,1,0,0,1,1,1,0,1,1,0,0,0,1,0,0],PolyVal [0,0,0,1,1,1,1,0,1,0,0,0,1,1,0,0],PolyVal [1,1,1,1,0,0,0,0,0,1,0,0,0,1,1,0],PolyVal [1,0,1,1,0,1,0,0,0,0,1,1,1,0,0,0],PolyVal [1,0,1,1,0,1,0,0,1,0,1,1,1,1,0,0]],VectorVal [PolyVal [1,1,1,1,0,0,1,0,0,1,1,0,0,0,1,0],PolyVal [0,0,0,1,0,0,0,0,0,0,1,1,1,0,0,0],PolyVal [0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0],PolyVal [1,1,1,0,1,0,1,0,0,1,1,0,1,0,0,0],PolyVal [1,1,1,0,1,1,0,1,0,0,0,0,1,0,1,0],PolyVal [1,1,1,0,1,1,0,1,1,0,1,0,0,1,1,1],PolyVal [1,0,0,0,0,1,1,0,1,1,1,1,1,1,0,1],PolyVal [0,1,1,0,1,1,0,0,0,0,0,0,1,1,0,1]],VectorVal [PolyVal [0,0,0,0,0,1,0,1,1,1,1,1,1,1,1,1],PolyVal [1,0,0,1,0,0,0,0,1,0,1,1,0,1,1,0],PolyVal [1,1,1,1,1,0,0,1,1,0,0,0,0,1,1,1],PolyVal [1,0,0,1,1,0,1,1,1,1,1,0,0,0,0,1],PolyVal [0,0,1,1,1,1,1,0,1,1,1,1,0,1,1,0],PolyVal [1,1,1,1,1,0,1,0,1,0,0,0,1,0,1,0],PolyVal [0,0,1,1,0,1,0,1,1,1,1,0,1,0,0,0],PolyVal [1,1,1,1,0,1,1,0,0,1,0,0,1,0,1,0]]]], start_saturated = False}";
      int reported = 0;
      arg2.val[0] = vcombine_p16(vcreate_p16(UINT64_C(0x237363d9f61ef571)),
                                 vcreate_p16(UINT64_C(0x3d2d1c2d620f3178)));
      arg2.val[1] = vcombine_p16(vcreate_p16(UINT64_C(0x165712101c08464f)),
                                 vcreate_p16(UINT64_C(0xb036bf61e5b750b7)));
      arg2.val[2] = vcombine_p16(vcreate_p16(UINT64_C(0x87d9e19f6d09ffa0)),
                                 vcreate_p16(UINT64_C(0x526f17ac515f6f7c)));
      clear_neon_saturated();
      vst3q_p16(result, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         poly16_t got;
         poly16_t exp;
         got = result[0];
         exp = 62833;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 0 ",
                      exp,
                      got);
            }
      }
      {
         poly16_t got;
         poly16_t exp;
         got = result[1];
         exp = 17999;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 1 ",
                      exp,
                      got);
            }
      }
      {
         poly16_t got;
         poly16_t exp;
         got = result[2];
         exp = 65440;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 2 ",
                      exp,
                      got);
            }
      }
      {
         poly16_t got;
         poly16_t exp;
         got = result[3];
         exp = 63006;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 3 ",
                      exp,
                      got);
            }
      }
      {
         poly16_t got;
         poly16_t exp;
         got = result[4];
         exp = 7176;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 4 ",
                      exp,
                      got);
            }
      }
      {
         poly16_t got;
         poly16_t exp;
         got = result[5];
         exp = 27913;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 5 ",
                      exp,
                      got);
            }
      }
      {
         poly16_t got;
         poly16_t exp;
         got = result[6];
         exp = 25561;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 6 ",
                      exp,
                      got);
            }
      }
      {
         poly16_t got;
         poly16_t exp;
         got = result[7];
         exp = 4624;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 7 ",
                      exp,
                      got);
            }
      }
      {
         poly16_t got;
         poly16_t exp;
         got = result[8];
         exp = 57759;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 8 ",
                      exp,
                      got);
            }
      }
      {
         poly16_t got;
         poly16_t exp;
         got = result[9];
         exp = 9075;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 9 ",
                      exp,
                      got);
            }
      }
      {
         poly16_t got;
         poly16_t exp;
         got = result[10];
         exp = 5719;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 10 ",
                      exp,
                      got);
            }
      }
      {
         poly16_t got;
         poly16_t exp;
         got = result[11];
         exp = 34777;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 11 ",
                      exp,
                      got);
            }
      }
      {
         poly16_t got;
         poly16_t exp;
         got = result[12];
         exp = 12664;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 12 ",
                      exp,
                      got);
            }
      }
      {
         poly16_t got;
         poly16_t exp;
         got = result[13];
         exp = 20663;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 13 ",
                      exp,
                      got);
            }
      }
      {
         poly16_t got;
         poly16_t exp;
         got = result[14];
         exp = 28540;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 14 ",
                      exp,
                      got);
            }
      }
      {
         poly16_t got;
         poly16_t exp;
         got = result[15];
         exp = 25103;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 15 ",
                      exp,
                      got);
            }
      }
      {
         poly16_t got;
         poly16_t exp;
         got = result[16];
         exp = 58807;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 16 ",
                      exp,
                      got);
            }
      }
      {
         poly16_t got;
         poly16_t exp;
         got = result[17];
         exp = 20831;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 17 ",
                      exp,
                      got);
            }
      }
      {
         poly16_t got;
         poly16_t exp;
         got = result[18];
         exp = 7213;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 18 ",
                      exp,
                      got);
            }
      }
      {
         poly16_t got;
         poly16_t exp;
         got = result[19];
         exp = 48993;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 19 ",
                      exp,
                      got);
            }
      }
      {
         poly16_t got;
         poly16_t exp;
         got = result[20];
         exp = 6060;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 20 ",
                      exp,
                      got);
            }
      }
      {
         poly16_t got;
         poly16_t exp;
         got = result[21];
         exp = 15661;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 21 ",
                      exp,
                      got);
            }
      }
      {
         poly16_t got;
         poly16_t exp;
         got = result[22];
         exp = 45110;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 22 ",
                      exp,
                      got);
            }
      }
      {
         poly16_t got;
         poly16_t exp;
         got = result[23];
         exp = 21103;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 23 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1614() {
#if __ARM_NEON_FP16_INTRINSICS

{
   {
      float16x8x3_t arg2;
      __fp16 result[24];
      char* str1 = "ReproInfo2 {semantics = \"store3\", fnname = \"vst3q_f16\", rettype = \"__transfersize(24) __fp16 *\", argtypes = \"[/* result holder */,float16x8x3_t]\", vals = [PtrVal [],ArrayVal [VectorVal [FloatVal (-9.582229879349777),FloatVal 7.392059457983439,FloatVal 9.661051584199548,FloatVal (-3.1061092876923224),FloatVal 1.6703909598501028,FloatVal (-8.869403148118355),FloatVal 0.788033988215977,FloatVal 6.678231009433617],VectorVal [FloatVal 6.920491045039292,FloatVal (-2.2932930569308674),FloatVal 9.906792433530377,FloatVal (-9.878955126118674),FloatVal 9.267305163838966,FloatVal (-3.969882036198616),FloatVal 3.5817616019998724,FloatVal 0.4748540289475418],VectorVal [FloatVal 0.2783843888802906,FloatVal 1.4600838514315928,FloatVal 9.728520891878485,FloatVal (-1.6038467162675119),FloatVal 6.206821923936893,FloatVal 3.371202221487973,FloatVal (-8.948280751001274),FloatVal (-6.478927901751139)]]], start_saturated = False}";
      int reported = 0;
      arg2.val[0] = vcombine_f16(vcreate_f16(UINT64_C(0xc23648d44764c8ca)),
                                 vcreate_f16(UINT64_C(0x46ad3a4dc86f3eae)));
      arg2.val[1] = vcombine_f16(vcreate_f16(UINT64_C(0xc8f048f4c09646eb)),
                                 vcreate_f16(UINT64_C(0x37994329c3f048a2)));
      arg2.val[2] = vcombine_f16(vcreate_f16(UINT64_C(0xbe6a48dd3dd73474)),
                                 vcreate_f16(UINT64_C(0xc67ac87942be4634)));
      clear_neon_saturated();
      vst3q_f16(result, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         __fp16 got;
         __fp16 exp;
         got = result[0];
         exp = -9.582229879349777;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 0 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = result[1];
         exp = 6.920491045039292;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 1 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = result[2];
         exp = 0.2783843888802906;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 2 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = result[3];
         exp = 7.392059457983439;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 3 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = result[4];
         exp = -2.2932930569308674;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 4 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = result[5];
         exp = 1.4600838514315928;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 5 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = result[6];
         exp = 9.661051584199548;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 6 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = result[7];
         exp = 9.906792433530377;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 7 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = result[8];
         exp = 9.728520891878485;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 8 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = result[9];
         exp = -3.1061092876923224;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 9 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = result[10];
         exp = -9.878955126118674;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 10 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = result[11];
         exp = -1.6038467162675119;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 11 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = result[12];
         exp = 1.6703909598501028;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 12 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = result[13];
         exp = 9.267305163838966;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 13 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = result[14];
         exp = 6.206821923936893;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 14 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = result[15];
         exp = -8.869403148118355;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 15 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = result[16];
         exp = -3.969882036198616;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 16 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = result[17];
         exp = 3.371202221487973;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 17 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = result[18];
         exp = 0.788033988215977;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 18 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = result[19];
         exp = 3.5817616019998724;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 19 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = result[20];
         exp = -8.948280751001274;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 20 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = result[21];
         exp = 6.678231009433617;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 21 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = result[22];
         exp = 0.4748540289475418;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 22 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = result[23];
         exp = -6.478927901751139;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 23 ", exp, got);
            }
      }
   }
}
#endif
}
void dotests_1615() {

{
   {
      poly64x2x3_t arg2;
      poly64_t result[6];
      char* str1 = "ReproInfo2 {semantics = \"store3\", fnname = \"vst3q_p64\", rettype = \"__transfersize(6) poly64_t *\", argtypes = \"[/* result holder */,poly64x2x3_t]\", vals = [PtrVal [],ArrayVal [VectorVal [PolyVal [1,0,1,1,0,0,0,1,0,1,1,1,0,1,1,0,0,0,1,1,0,1,0,1,0,1,1,0,0,1,1,1,1,0,0,0,0,0,1,0,1,0,0,1,1,0,0,1,1,0,1,1,0,0,1,0,0,1,1,0,1,1,1,0],PolyVal [1,1,1,1,1,0,1,1,1,1,0,0,0,1,0,0,1,1,1,1,0,0,1,0,1,1,0,1,0,1,1,1,0,0,0,1,1,0,0,0,1,0,1,1,0,1,1,1,0,1,0,0,0,0,0,1,0,1,0,0,0,1,0,1]],VectorVal [PolyVal [1,0,1,0,0,0,0,1,1,1,1,1,0,0,0,0,1,0,1,0,0,0,1,1,1,0,0,1,1,1,0,0,0,0,1,1,1,0,1,0,1,0,1,0,0,0,1,1,1,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0],PolyVal [1,0,1,1,1,1,0,1,1,0,0,1,1,1,0,1,1,1,0,0,0,1,0,1,0,0,1,1,0,1,0,1,0,1,1,1,0,1,0,1,0,1,1,1,1,0,0,0,0,0,1,1,0,1,0,0,1,1,1,1,0,0,1,1]],VectorVal [PolyVal [1,1,1,1,0,0,0,1,1,0,0,1,0,0,1,0,0,1,1,0,0,1,1,1,1,0,0,1,1,1,1,1,0,0,0,1,0,0,1,1,1,1,1,0,1,0,0,0,1,1,1,1,1,0,0,0,1,0,0,1,0,1,0,0],PolyVal [1,0,1,1,0,0,1,0,0,0,0,0,1,1,0,1,0,1,0,1,1,0,1,1,0,0,1,0,1,0,0,0,1,1,0,0,1,1,0,1,1,0,0,0,1,0,1,1,1,0,1,0,0,1,1,0,1,1,0,1,0,1,1,0]]]], start_saturated = False}";
      int reported = 0;
      arg2.val[0] = vcombine_p64(vcreate_p64(UINT64_C(0x764d9941e6ac6e8d)),
                                 vcreate_p64(UINT64_C(0xa282ed18eb4f23df)));
      arg2.val[1] = vcombine_p64(vcreate_p64(UINT64_C(0x2489c55c39c50f85)),
                                 vcreate_p64(UINT64_C(0xcf2c1eaeaca3b9bd)));
      arg2.val[2] = vcombine_p64(vcreate_p64(UINT64_C(0x291f17c8f9e6498f)),
                                 vcreate_p64(UINT64_C(0x6b65d1b314dab04d)));
      clear_neon_saturated();
      vst3q_p64(result, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         poly64_t got;
         poly64_t exp;
         got = result[0];
         exp = 8524638178004201101;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu64 " Got: %" PRIu64 "\n",
                      "   Elem 0 ",
                      exp,
                      got);
            }
      }
      {
         poly64_t got;
         poly64_t exp;
         got = result[1];
         exp = 2632852457071644549;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu64 " Got: %" PRIu64 "\n",
                      "   Elem 1 ",
                      exp,
                      got);
            }
      }
      {
         poly64_t got;
         poly64_t exp;
         got = result[2];
         exp = 2963113231786592655;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu64 " Got: %" PRIu64 "\n",
                      "   Elem 2 ",
                      exp,
                      got);
            }
      }
      {
         poly64_t got;
         poly64_t exp;
         got = result[3];
         exp = -6736561401310010401;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu64 " Got: %" PRIu64 "\n",
                      "   Elem 3 ",
                      exp,
                      got);
            }
      }
      {
         poly64_t got;
         poly64_t exp;
         got = result[4];
         exp = -3518403473313646147;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu64 " Got: %" PRIu64 "\n",
                      "   Elem 4 ",
                      exp,
                      got);
            }
      }
      {
         poly64_t got;
         poly64_t exp;
         got = result[5];
         exp = 7738822101785292877;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu64 " Got: %" PRIu64 "\n",
                      "   Elem 5 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1616() {

{
   {
      uint8x8x3_t arg2;
      uint8_t result[24];
      char* str1 = "ReproInfo2 {semantics = \"store3\", fnname = \"vst3_u8\", rettype = \"__transfersize(24) uint8_t *\", argtypes = \"[/* result holder */,uint8x8x3_t]\", vals = [PtrVal [],ArrayVal [VectorVal [IntegerVal 210,IntegerVal 75,IntegerVal 0,IntegerVal 0,IntegerVal 23,IntegerVal 128,IntegerVal 127,IntegerVal 255],VectorVal [IntegerVal 0,IntegerVal 75,IntegerVal 128,IntegerVal 127,IntegerVal 255,IntegerVal 0,IntegerVal 99,IntegerVal 255],VectorVal [IntegerVal 128,IntegerVal 151,IntegerVal 255,IntegerVal 255,IntegerVal 132,IntegerVal 127,IntegerVal 255,IntegerVal 127]]], start_saturated = False}";
      int reported = 0;
      arg2.val[0] = vcreate_u8(UINT64_C(0xff7f801700004bd2));
      arg2.val[1] = vcreate_u8(UINT64_C(0xff6300ff7f804b00));
      arg2.val[2] = vcreate_u8(UINT64_C(0x7fff7f84ffff9780));
      clear_neon_saturated();
      vst3_u8(result, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint8_t got;
         uint8_t exp;
         got = result[0];
         exp = 210U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 0 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[1];
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 1 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[2];
         exp = 128U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 2 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[3];
         exp = 75U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 3 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[4];
         exp = 75U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 4 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[5];
         exp = 151U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 5 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[6];
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 6 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[7];
         exp = 128U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 7 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[8];
         exp = 255U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 8 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[9];
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 9 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[10];
         exp = 127U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 10 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[11];
         exp = 255U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 11 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[12];
         exp = 23U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 12 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[13];
         exp = 255U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 13 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[14];
         exp = 132U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 14 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[15];
         exp = 128U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 15 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[16];
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 16 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[17];
         exp = 127U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 17 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[18];
         exp = 127U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 18 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[19];
         exp = 99U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 19 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[20];
         exp = 255U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 20 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[21];
         exp = 255U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 21 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[22];
         exp = 255U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 22 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[23];
         exp = 127U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 23 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1617() {

{
   {
      uint16x4x3_t arg2;
      uint16_t result[12];
      char* str1 = "ReproInfo2 {semantics = \"store3\", fnname = \"vst3_u16\", rettype = \"__transfersize(12) uint16_t *\", argtypes = \"[/* result holder */,uint16x4x3_t]\", vals = [PtrVal [],ArrayVal [VectorVal [IntegerVal 32768,IntegerVal 32767,IntegerVal 32768,IntegerVal 32768],VectorVal [IntegerVal 32768,IntegerVal 0,IntegerVal 0,IntegerVal 65535],VectorVal [IntegerVal 32767,IntegerVal 32767,IntegerVal 43456,IntegerVal 0]]], start_saturated = False}";
      int reported = 0;
      arg2.val[0] = vcreate_u16(UINT64_C(0x800080007fff8000));
      arg2.val[1] = vcreate_u16(UINT64_C(0xffff000000008000));
      arg2.val[2] = vcreate_u16(UINT64_C(0x0000a9c07fff7fff));
      clear_neon_saturated();
      vst3_u16(result, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint16_t got;
         uint16_t exp;
         got = result[0];
         exp = 32768U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 0 ",
                      exp,
                      got);
            }
      }
      {
         uint16_t got;
         uint16_t exp;
         got = result[1];
         exp = 32768U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 1 ",
                      exp,
                      got);
            }
      }
      {
         uint16_t got;
         uint16_t exp;
         got = result[2];
         exp = 32767U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 2 ",
                      exp,
                      got);
            }
      }
      {
         uint16_t got;
         uint16_t exp;
         got = result[3];
         exp = 32767U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 3 ",
                      exp,
                      got);
            }
      }
      {
         uint16_t got;
         uint16_t exp;
         got = result[4];
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 4 ",
                      exp,
                      got);
            }
      }
      {
         uint16_t got;
         uint16_t exp;
         got = result[5];
         exp = 32767U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 5 ",
                      exp,
                      got);
            }
      }
      {
         uint16_t got;
         uint16_t exp;
         got = result[6];
         exp = 32768U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 6 ",
                      exp,
                      got);
            }
      }
      {
         uint16_t got;
         uint16_t exp;
         got = result[7];
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 7 ",
                      exp,
                      got);
            }
      }
      {
         uint16_t got;
         uint16_t exp;
         got = result[8];
         exp = 43456U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 8 ",
                      exp,
                      got);
            }
      }
      {
         uint16_t got;
         uint16_t exp;
         got = result[9];
         exp = 32768U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 9 ",
                      exp,
                      got);
            }
      }
      {
         uint16_t got;
         uint16_t exp;
         got = result[10];
         exp = 65535U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 10 ",
                      exp,
                      got);
            }
      }
      {
         uint16_t got;
         uint16_t exp;
         got = result[11];
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 11 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1618() {

{
   {
      uint32x2x3_t arg2;
      uint32_t result[6];
      char* str1 = "ReproInfo2 {semantics = \"store3\", fnname = \"vst3_u32\", rettype = \"__transfersize(6) uint32_t *\", argtypes = \"[/* result holder */,uint32x2x3_t]\", vals = [PtrVal [],ArrayVal [VectorVal [IntegerVal 3973584484,IntegerVal 65535],VectorVal [IntegerVal 2147549183,IntegerVal 2147499399],VectorVal [IntegerVal 4123033599,IntegerVal 0]]], start_saturated = False}";
      int reported = 0;
      arg2.val[0] = vcreate_u32(UINT64_C(0x0000ffffecd81664));
      arg2.val[1] = vcreate_u32(UINT64_C(0x80003d878000ffff));
      arg2.val[2] = vcreate_u32(UINT64_C(0x00000000f5c07fff));
      clear_neon_saturated();
      vst3_u32(result, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint32_t got;
         uint32_t exp;
         got = result[0];
         exp = 3973584484U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu32 " Got: %" PRIu32 "\n",
                      "   Elem 0 ",
                      exp,
                      got);
            }
      }
      {
         uint32_t got;
         uint32_t exp;
         got = result[1];
         exp = 2147549183U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu32 " Got: %" PRIu32 "\n",
                      "   Elem 1 ",
                      exp,
                      got);
            }
      }
      {
         uint32_t got;
         uint32_t exp;
         got = result[2];
         exp = 4123033599U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu32 " Got: %" PRIu32 "\n",
                      "   Elem 2 ",
                      exp,
                      got);
            }
      }
      {
         uint32_t got;
         uint32_t exp;
         got = result[3];
         exp = 65535U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu32 " Got: %" PRIu32 "\n",
                      "   Elem 3 ",
                      exp,
                      got);
            }
      }
      {
         uint32_t got;
         uint32_t exp;
         got = result[4];
         exp = 2147499399U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu32 " Got: %" PRIu32 "\n",
                      "   Elem 4 ",
                      exp,
                      got);
            }
      }
      {
         uint32_t got;
         uint32_t exp;
         got = result[5];
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu32 " Got: %" PRIu32 "\n",
                      "   Elem 5 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1619() {

{
   {
      uint64x1x3_t arg2;
      uint64_t result[3];
      char* str1 = "ReproInfo2 {semantics = \"store3\", fnname = \"vst3_u64\", rettype = \"__transfersize(3) uint64_t *\", argtypes = \"[/* result holder */,uint64x1x3_t]\", vals = [PtrVal [],ArrayVal [VectorVal [IntegerVal 18446462603027808255],VectorVal [IntegerVal 9223372034707292159],VectorVal [IntegerVal 9223512772195581952]]], start_saturated = False}";
      int reported = 0;
      arg2.val[0] = vcreate_u64(UINT64_C(0xffff0000ffffffff));
      arg2.val[1] = vcreate_u64(UINT64_C(0x7fffffff7fffffff));
      arg2.val[2] = vcreate_u64(UINT64_C(0x80007fff7fff0000));
      clear_neon_saturated();
      vst3_u64(result, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = result[0];
         exp = UINT64_C(0xffff0000ffffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Elem 0 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = result[1];
         exp = UINT64_C(0x7fffffff7fffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Elem 1 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = result[2];
         exp = UINT64_C(0x80007fff7fff0000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Elem 2 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1620() {

{
   {
      int8x8x3_t arg2;
      int8_t result[24];
      char* str1 = "ReproInfo2 {semantics = \"store3\", fnname = \"vst3_s8\", rettype = \"__transfersize(24) int8_t *\", argtypes = \"[/* result holder */,int8x8x3_t]\", vals = [PtrVal [],ArrayVal [VectorVal [IntegerVal 67,IntegerVal 0,IntegerVal (-1),IntegerVal 0,IntegerVal 127,IntegerVal (-1),IntegerVal (-1),IntegerVal 0],VectorVal [IntegerVal (-128),IntegerVal (-1),IntegerVal (-42),IntegerVal (-125),IntegerVal (-1),IntegerVal (-128),IntegerVal (-1),IntegerVal 127],VectorVal [IntegerVal (-1),IntegerVal (-1),IntegerVal 127,IntegerVal 127,IntegerVal 127,IntegerVal (-128),IntegerVal (-1),IntegerVal 0]]], start_saturated = False}";
      int reported = 0;
      arg2.val[0] = vcreate_s8(UINT64_C(0x00ffff7f00ff0043));
      arg2.val[1] = vcreate_s8(UINT64_C(0x7fff80ff83d6ff80));
      arg2.val[2] = vcreate_s8(UINT64_C(0x00ff807f7f7fffff));
      clear_neon_saturated();
      vst3_s8(result, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         int8_t got;
         int8_t exp;
         got = result[0];
         exp = 67;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 0 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[1];
         exp = -128;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 1 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[2];
         exp = -1;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 2 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[3];
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 3 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[4];
         exp = -1;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 4 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[5];
         exp = -1;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 5 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[6];
         exp = -1;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 6 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[7];
         exp = -42;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 7 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[8];
         exp = 127;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 8 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[9];
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 9 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[10];
         exp = -125;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 10 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[11];
         exp = 127;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 11 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[12];
         exp = 127;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 12 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[13];
         exp = -1;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 13 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[14];
         exp = 127;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 14 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[15];
         exp = -1;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 15 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[16];
         exp = -128;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 16 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[17];
         exp = -128;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 17 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[18];
         exp = -1;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 18 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[19];
         exp = -1;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 19 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[20];
         exp = -1;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 20 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[21];
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 21 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[22];
         exp = 127;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 22 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[23];
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 23 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1621() {

{
   {
      int16x4x3_t arg2;
      int16_t result[12];
      char* str1 = "ReproInfo2 {semantics = \"store3\", fnname = \"vst3_s16\", rettype = \"__transfersize(12) int16_t *\", argtypes = \"[/* result holder */,int16x4x3_t]\", vals = [PtrVal [],ArrayVal [VectorVal [IntegerVal 0,IntegerVal (-1),IntegerVal (-25108),IntegerVal (-31293)],VectorVal [IntegerVal (-1),IntegerVal (-1),IntegerVal (-2679),IntegerVal (-1)],VectorVal [IntegerVal (-11551),IntegerVal 0,IntegerVal (-32768),IntegerVal 946]]], start_saturated = False}";
      int reported = 0;
      arg2.val[0] = vcreate_s16(UINT64_C(0x85c39decffff0000));
      arg2.val[1] = vcreate_s16(UINT64_C(0xfffff589ffffffff));
      arg2.val[2] = vcreate_s16(UINT64_C(0x03b280000000d2e1));
      clear_neon_saturated();
      vst3_s16(result, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         int16_t got;
         int16_t exp;
         got = result[0];
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi16 " Got: %" PRIi16 "\n",
                      "   Elem 0 ",
                      exp,
                      got);
            }
      }
      {
         int16_t got;
         int16_t exp;
         got = result[1];
         exp = -1;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi16 " Got: %" PRIi16 "\n",
                      "   Elem 1 ",
                      exp,
                      got);
            }
      }
      {
         int16_t got;
         int16_t exp;
         got = result[2];
         exp = -11551;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi16 " Got: %" PRIi16 "\n",
                      "   Elem 2 ",
                      exp,
                      got);
            }
      }
      {
         int16_t got;
         int16_t exp;
         got = result[3];
         exp = -1;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi16 " Got: %" PRIi16 "\n",
                      "   Elem 3 ",
                      exp,
                      got);
            }
      }
      {
         int16_t got;
         int16_t exp;
         got = result[4];
         exp = -1;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi16 " Got: %" PRIi16 "\n",
                      "   Elem 4 ",
                      exp,
                      got);
            }
      }
      {
         int16_t got;
         int16_t exp;
         got = result[5];
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi16 " Got: %" PRIi16 "\n",
                      "   Elem 5 ",
                      exp,
                      got);
            }
      }
      {
         int16_t got;
         int16_t exp;
         got = result[6];
         exp = -25108;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi16 " Got: %" PRIi16 "\n",
                      "   Elem 6 ",
                      exp,
                      got);
            }
      }
      {
         int16_t got;
         int16_t exp;
         got = result[7];
         exp = -2679;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi16 " Got: %" PRIi16 "\n",
                      "   Elem 7 ",
                      exp,
                      got);
            }
      }
      {
         int16_t got;
         int16_t exp;
         got = result[8];
         exp = -32768;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi16 " Got: %" PRIi16 "\n",
                      "   Elem 8 ",
                      exp,
                      got);
            }
      }
      {
         int16_t got;
         int16_t exp;
         got = result[9];
         exp = -31293;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi16 " Got: %" PRIi16 "\n",
                      "   Elem 9 ",
                      exp,
                      got);
            }
      }
      {
         int16_t got;
         int16_t exp;
         got = result[10];
         exp = -1;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi16 " Got: %" PRIi16 "\n",
                      "   Elem 10 ",
                      exp,
                      got);
            }
      }
      {
         int16_t got;
         int16_t exp;
         got = result[11];
         exp = 946;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi16 " Got: %" PRIi16 "\n",
                      "   Elem 11 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1622() {

{
   {
      int32x2x3_t arg2;
      int32_t result[6];
      char* str1 = "ReproInfo2 {semantics = \"store3\", fnname = \"vst3_s32\", rettype = \"__transfersize(6) int32_t *\", argtypes = \"[/* result holder */,int32x2x3_t]\", vals = [PtrVal [],ArrayVal [VectorVal [IntegerVal 1556840447,IntegerVal (-65536)],VectorVal [IntegerVal (-2147450880),IntegerVal (-2147418113)],VectorVal [IntegerVal (-2147483648),IntegerVal (-2147450881)]]], start_saturated = False}";
      int reported = 0;
      arg2.val[0] = vcreate_s32(UINT64_C(0xffff00005ccb7fff));
      arg2.val[1] = vcreate_s32(UINT64_C(0x8000ffff80008000));
      arg2.val[2] = vcreate_s32(UINT64_C(0x80007fff80000000));
      clear_neon_saturated();
      vst3_s32(result, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         int32_t got;
         int32_t exp;
         got = result[0];
         exp = 1556840447;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi32 " Got: %" PRIi32 "\n",
                      "   Elem 0 ",
                      exp,
                      got);
            }
      }
      {
         int32_t got;
         int32_t exp;
         got = result[1];
         exp = -2147450880;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi32 " Got: %" PRIi32 "\n",
                      "   Elem 1 ",
                      exp,
                      got);
            }
      }
      {
         int32_t got;
         int32_t exp;
         got = result[2];
         exp = (int32_t) 0x80000000;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi32 " Got: %" PRIi32 "\n",
                      "   Elem 2 ",
                      exp,
                      got);
            }
      }
      {
         int32_t got;
         int32_t exp;
         got = result[3];
         exp = -65536;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi32 " Got: %" PRIi32 "\n",
                      "   Elem 3 ",
                      exp,
                      got);
            }
      }
      {
         int32_t got;
         int32_t exp;
         got = result[4];
         exp = -2147418113;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi32 " Got: %" PRIi32 "\n",
                      "   Elem 4 ",
                      exp,
                      got);
            }
      }
      {
         int32_t got;
         int32_t exp;
         got = result[5];
         exp = -2147450881;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi32 " Got: %" PRIi32 "\n",
                      "   Elem 5 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1623() {

{
   {
      int64x1x3_t arg2;
      int64_t result[3];
      char* str1 = "ReproInfo2 {semantics = \"store3\", fnname = \"vst3_s64\", rettype = \"__transfersize(3) int64_t *\", argtypes = \"[/* result holder */,int64x1x3_t]\", vals = [PtrVal [],ArrayVal [VectorVal [IntegerVal (-189934582791918)],VectorVal [IntegerVal 9223160234837577807],VectorVal [IntegerVal (-218764159156225)]]], start_saturated = False}";
      int reported = 0;
      arg2.val[0] = vcreate_s64(UINT64_C(0xffff534168a98112));
      arg2.val[1] = vcreate_s64(UINT64_C(0x7fff3f5e0000904f));
      arg2.val[2] = vcreate_s64(UINT64_C(0xffff39090000ffff));
      clear_neon_saturated();
      vst3_s64(result, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         int64_t got;
         int64_t exp;
         got = result[0];
         exp = INT64_C(-189934582791918);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi64 " Got: %" PRIi64 "\n",
                      "   Elem 0 ",
                      exp,
                      got);
            }
      }
      {
         int64_t got;
         int64_t exp;
         got = result[1];
         exp = INT64_C(9223160234837577807);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi64 " Got: %" PRIi64 "\n",
                      "   Elem 1 ",
                      exp,
                      got);
            }
      }
      {
         int64_t got;
         int64_t exp;
         got = result[2];
         exp = INT64_C(-218764159156225);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi64 " Got: %" PRIi64 "\n",
                      "   Elem 2 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1624() {

{
   {
      float32x2x3_t arg2;
      float32_t result[6];
      char* str1 = "ReproInfo2 {semantics = \"store3\", fnname = \"vst3_f32\", rettype = \"__transfersize(6) float32_t *\", argtypes = \"[/* result holder */,float32x2x3_t]\", vals = [PtrVal [],ArrayVal [VectorVal [FloatVal 0.37556368112564087,FloatVal 0.9637449979782104],VectorVal [FloatVal 0.5931411981582642,FloatVal 3.0720889568328857e-2],VectorVal [FloatVal 0.2977777123451233,FloatVal 0.2767181992530823]]], start_saturated = True}";
      int reported = 0;
      arg2.val[0] = vcreate_f32(UINT64_C(0x3f76b7fe3ec049e2));
      arg2.val[1] = vcreate_f32(UINT64_C(0x3cfbaa603f17d81a));
      arg2.val[2] = vcreate_f32(UINT64_C(0x3e8dae023e987652));
      set_neon_saturated();
      vst3_f32(result, arg2);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = result[0];
         exp = ((float32_t) 0.37556368112564087);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 0 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = result[1];
         exp = ((float32_t) 0.5931411981582642);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 1 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = result[2];
         exp = ((float32_t) 0.2977777123451233);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 2 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = result[3];
         exp = ((float32_t) 0.9637449979782104);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 3 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = result[4];
         exp = ((float32_t) 3.0720889568328857e-2);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 4 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = result[5];
         exp = ((float32_t) 0.2767181992530823);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 5 ", exp, got);
            }
      }
   }
}
}
void dotests_1625() {

{
   {
      float64x1x3_t arg2;
      float64_t result[3];
      char* str1 = "ReproInfo2 {semantics = \"store3\", fnname = \"vst3_f64\", rettype = \"__transfersize(3) float64_t *\", argtypes = \"[/* result holder */,float64x1x3_t]\", vals = [PtrVal [],ArrayVal [VectorVal [FloatVal 0.8000459643994672],VectorVal [FloatVal 0.65723722266046],VectorVal [FloatVal 0.19006598178577783]]], start_saturated = False}";
      int reported = 0;
      arg2.val[0] = vcreate_f64(UINT64_C(0x3fe999f9fe8c8f4b));
      arg2.val[1] = vcreate_f64(UINT64_C(0x3fe508165b214c27));
      arg2.val[2] = vcreate_f64(UINT64_C(0x3fc8541503ed0fe4));
      clear_neon_saturated();
      vst3_f64(result, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float64_t got;
         float64_t exp;
         got = result[0];
         exp = 0.8000459643994672;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 0 ", exp, got);
            }
      }
      {
         float64_t got;
         float64_t exp;
         got = result[1];
         exp = 0.65723722266046;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 1 ", exp, got);
            }
      }
      {
         float64_t got;
         float64_t exp;
         got = result[2];
         exp = 0.19006598178577783;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 2 ", exp, got);
            }
      }
   }
}
}
void dotests_1626() {

{
   {
      poly8x8x3_t arg2;
      poly8_t result[24];
      char* str1 = "ReproInfo2 {semantics = \"store3\", fnname = \"vst3_p8\", rettype = \"__transfersize(24) poly8_t *\", argtypes = \"[/* result holder */,poly8x8x3_t]\", vals = [PtrVal [],ArrayVal [VectorVal [PolyVal [1,0,1,1,1,1,1,0],PolyVal [0,1,1,1,1,1,0,1],PolyVal [1,1,1,0,0,0,0,0],PolyVal [0,0,0,0,0,0,1,0],PolyVal [1,1,1,1,1,1,0,1],PolyVal [0,0,1,0,1,1,0,1],PolyVal [1,1,1,1,1,0,1,1],PolyVal [1,1,0,1,0,0,0,0]],VectorVal [PolyVal [0,0,0,1,0,0,0,0],PolyVal [0,1,0,1,1,1,1,0],PolyVal [1,0,1,1,1,1,0,1],PolyVal [0,1,1,0,1,1,1,0],PolyVal [1,1,1,0,0,0,0,0],PolyVal [1,1,1,0,0,0,1,1],PolyVal [0,0,0,1,0,0,0,0],PolyVal [1,0,1,1,0,0,1,0]],VectorVal [PolyVal [0,0,1,1,0,1,1,0],PolyVal [1,0,1,0,0,0,1,0],PolyVal [1,1,1,1,0,0,1,1],PolyVal [1,0,1,1,1,1,1,0],PolyVal [1,0,1,1,0,1,0,1],PolyVal [0,1,0,1,0,0,1,0],PolyVal [1,1,0,0,1,1,1,1],PolyVal [0,0,1,0,0,0,0,0]]]], start_saturated = False}";
      int reported = 0;
      arg2.val[0] = vcreate_p8(UINT64_C(0x0bdfb4bf4007be7d));
      arg2.val[1] = vcreate_p8(UINT64_C(0x4d08c70776bd7a08));
      arg2.val[2] = vcreate_p8(UINT64_C(0x04f34aad7dcf456c));
      clear_neon_saturated();
      vst3_p8(result, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         poly8_t got;
         poly8_t exp;
         got = result[0];
         exp = 125;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 0 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[1];
         exp = 8;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 1 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[2];
         exp = 108;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 2 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[3];
         exp = 190;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 3 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[4];
         exp = 122;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 4 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[5];
         exp = 69;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 5 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[6];
         exp = 7;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 6 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[7];
         exp = 189;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 7 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[8];
         exp = 207;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 8 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[9];
         exp = 64;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 9 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[10];
         exp = 118;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 10 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[11];
         exp = 125;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 11 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[12];
         exp = 191;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 12 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[13];
         exp = 7;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 13 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[14];
         exp = 173;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 14 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[15];
         exp = 180;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 15 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[16];
         exp = 199;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 16 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[17];
         exp = 74;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 17 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[18];
         exp = 223;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 18 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[19];
         exp = 8;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 19 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[20];
         exp = 243;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 20 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[21];
         exp = 11;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 21 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[22];
         exp = 77;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 22 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[23];
         exp = 4;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 23 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1627() {

{
   {
      poly16x4x3_t arg2;
      poly16_t result[12];
      char* str1 = "ReproInfo2 {semantics = \"store3\", fnname = \"vst3_p16\", rettype = \"__transfersize(12) poly16_t *\", argtypes = \"[/* result holder */,poly16x4x3_t]\", vals = [PtrVal [],ArrayVal [VectorVal [PolyVal [0,0,1,0,0,0,0,0,0,0,1,1,1,1,0,0],PolyVal [1,0,1,0,0,0,1,1,0,1,0,1,1,0,1,0],PolyVal [0,1,0,1,0,1,1,0,1,0,1,0,0,0,0,1],PolyVal [1,1,0,0,1,1,1,1,1,1,0,1,0,0,1,0]],VectorVal [PolyVal [1,1,0,0,1,0,1,0,1,1,0,1,0,0,1,1],PolyVal [1,1,1,0,1,0,1,0,0,1,1,0,0,0,0,0],PolyVal [0,1,1,0,1,0,0,1,0,0,0,1,1,0,1,1],PolyVal [1,1,1,0,1,1,1,1,1,1,0,1,0,0,0,0]],VectorVal [PolyVal [0,1,1,1,1,0,0,0,1,1,1,0,0,1,0,0],PolyVal [0,1,1,1,0,0,1,0,0,1,0,0,0,1,1,0],PolyVal [0,0,1,1,0,0,0,1,0,1,1,1,1,0,0,0],PolyVal [0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,1]]]], start_saturated = False}";
      int reported = 0;
      arg2.val[0] = vcreate_p16(UINT64_C(0x4bf3856a5ac53c04));
      arg2.val[1] = vcreate_p16(UINT64_C(0x0bf7d8960657cb53));
      arg2.val[2] = vcreate_p16(UINT64_C(0x95001e8c624e271e));
      clear_neon_saturated();
      vst3_p16(result, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         poly16_t got;
         poly16_t exp;
         got = result[0];
         exp = 15364;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 0 ",
                      exp,
                      got);
            }
      }
      {
         poly16_t got;
         poly16_t exp;
         got = result[1];
         exp = 52051;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 1 ",
                      exp,
                      got);
            }
      }
      {
         poly16_t got;
         poly16_t exp;
         got = result[2];
         exp = 10014;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 2 ",
                      exp,
                      got);
            }
      }
      {
         poly16_t got;
         poly16_t exp;
         got = result[3];
         exp = 23237;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 3 ",
                      exp,
                      got);
            }
      }
      {
         poly16_t got;
         poly16_t exp;
         got = result[4];
         exp = 1623;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 4 ",
                      exp,
                      got);
            }
      }
      {
         poly16_t got;
         poly16_t exp;
         got = result[5];
         exp = 25166;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 5 ",
                      exp,
                      got);
            }
      }
      {
         poly16_t got;
         poly16_t exp;
         got = result[6];
         exp = 34154;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 6 ",
                      exp,
                      got);
            }
      }
      {
         poly16_t got;
         poly16_t exp;
         got = result[7];
         exp = 55446;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 7 ",
                      exp,
                      got);
            }
      }
      {
         poly16_t got;
         poly16_t exp;
         got = result[8];
         exp = 7820;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 8 ",
                      exp,
                      got);
            }
      }
      {
         poly16_t got;
         poly16_t exp;
         got = result[9];
         exp = 19443;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 9 ",
                      exp,
                      got);
            }
      }
      {
         poly16_t got;
         poly16_t exp;
         got = result[10];
         exp = 3063;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 10 ",
                      exp,
                      got);
            }
      }
      {
         poly16_t got;
         poly16_t exp;
         got = result[11];
         exp = 38144;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 11 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1628() {
#if __ARM_NEON_FP16_INTRINSICS

{
   {
      float16x4x3_t arg2;
      __fp16 result[12];
      char* str1 = "ReproInfo2 {semantics = \"store3\", fnname = \"vst3_f16\", rettype = \"__transfersize(12) __fp16 *\", argtypes = \"[/* result holder */,float16x4x3_t]\", vals = [PtrVal [],ArrayVal [VectorVal [FloatVal 0.47876878827083047,FloatVal (-4.926105534800258),FloatVal (-9.031607242054553),FloatVal (-7.263112557609681)],VectorVal [FloatVal 5.013869811582843,FloatVal (-0.2356019863247063),FloatVal 0.949306625014783,FloatVal (-4.711151456112537)],VectorVal [FloatVal (-1.327523543673287),FloatVal (-1.930932357105073),FloatVal (-0.40471117304406334),FloatVal 1.233822783639413]]], start_saturated = False}";
      int reported = 0;
      arg2.val[0] = vcreate_f16(UINT64_C(0xc743c884c4ed37a9));
      arg2.val[1] = vcreate_f16(UINT64_C(0xc4b63b98b38a4503));
      arg2.val[2] = vcreate_f16(UINT64_C(0x3cefb679bfb9bd4f));
      clear_neon_saturated();
      vst3_f16(result, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         __fp16 got;
         __fp16 exp;
         got = result[0];
         exp = 0.47876878827083047;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 0 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = result[1];
         exp = 5.013869811582843;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 1 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = result[2];
         exp = -1.327523543673287;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 2 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = result[3];
         exp = -4.926105534800258;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 3 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = result[4];
         exp = -0.2356019863247063;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 4 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = result[5];
         exp = -1.930932357105073;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 5 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = result[6];
         exp = -9.031607242054553;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 6 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = result[7];
         exp = 0.949306625014783;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 7 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = result[8];
         exp = -0.40471117304406334;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 8 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = result[9];
         exp = -7.263112557609681;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 9 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = result[10];
         exp = -4.711151456112537;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 10 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = result[11];
         exp = 1.233822783639413;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 11 ", exp, got);
            }
      }
   }
}
#endif
}
void dotests_1629() {

{
   {
      poly64x1x3_t arg2;
      poly64_t result[3];
      char* str1 = "ReproInfo2 {semantics = \"store3\", fnname = \"vst3_p64\", rettype = \"__transfersize(3) poly64_t *\", argtypes = \"[/* result holder */,poly64x1x3_t]\", vals = [PtrVal [],ArrayVal [VectorVal [PolyVal [0,0,0,0,0,1,1,0,0,0,0,1,0,1,1,1,0,1,1,1,0,0,0,0,1,1,0,1,1,1,1,1,0,0,1,1,1,1,0,0,0,1,1,1,0,0,1,1,1,0,1,0,0,1,1,1,0,1,0,0,1,1,0,1]],VectorVal [PolyVal [1,0,1,0,0,1,1,0,1,0,0,0,0,0,0,1,1,0,0,1,0,0,1,0,0,1,1,1,0,1,1,1,0,1,0,0,1,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,1,1,1,1,1,0,0,1,1,1,1,0]],VectorVal [PolyVal [1,0,1,0,1,0,0,0,0,0,1,0,1,1,0,0,0,1,0,1,0,0,1,1,0,1,1,1,0,0,0,1,1,0,0,0,1,0,0,0,1,0,1,0,0,1,1,0,0,0,0,0,0,0,1,1,0,0,0,0,1,1,0,0]]]], start_saturated = False}";
      int reported = 0;
      arg2.val[0] = vcreate_p64(UINT64_C(0xb2e5ce3cfb0ee860));
      arg2.val[1] = vcreate_p64(UINT64_C(0x79f08a12ee498165));
      arg2.val[2] = vcreate_p64(UINT64_C(0x30c065118eca3415));
      clear_neon_saturated();
      vst3_p64(result, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         poly64_t got;
         poly64_t exp;
         got = result[0];
         exp = -5555807803986220960;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu64 " Got: %" PRIu64 "\n",
                      "   Elem 0 ",
                      exp,
                      got);
            }
      }
      {
         poly64_t got;
         poly64_t exp;
         got = result[1];
         exp = 8786674686911676773;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu64 " Got: %" PRIu64 "\n",
                      "   Elem 1 ",
                      exp,
                      got);
            }
      }
      {
         poly64_t got;
         poly64_t exp;
         got = result[2];
         exp = 3512918835433452565;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu64 " Got: %" PRIu64 "\n",
                      "   Elem 2 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1630() {

{
   {
      uint8x16x4_t arg2;
      uint8_t result[64];
      char* str1 = "ReproInfo2 {semantics = \"store4\", fnname = \"vst4q_u8\", rettype = \"__transfersize(64) uint8_t *\", argtypes = \"[/* result holder */,uint8x16x4_t]\", vals = [PtrVal [],ArrayVal [VectorVal [IntegerVal 0,IntegerVal 255,IntegerVal 0,IntegerVal 127,IntegerVal 0,IntegerVal 0,IntegerVal 50,IntegerVal 0,IntegerVal 127,IntegerVal 103,IntegerVal 127,IntegerVal 0,IntegerVal 127,IntegerVal 127,IntegerVal 255,IntegerVal 128],VectorVal [IntegerVal 128,IntegerVal 128,IntegerVal 128,IntegerVal 29,IntegerVal 35,IntegerVal 127,IntegerVal 127,IntegerVal 127,IntegerVal 128,IntegerVal 127,IntegerVal 128,IntegerVal 136,IntegerVal 143,IntegerVal 171,IntegerVal 128,IntegerVal 0],VectorVal [IntegerVal 128,IntegerVal 128,IntegerVal 0,IntegerVal 122,IntegerVal 127,IntegerVal 255,IntegerVal 191,IntegerVal 0,IntegerVal 128,IntegerVal 127,IntegerVal 128,IntegerVal 192,IntegerVal 0,IntegerVal 0,IntegerVal 0,IntegerVal 73],VectorVal [IntegerVal 56,IntegerVal 128,IntegerVal 0,IntegerVal 0,IntegerVal 145,IntegerVal 128,IntegerVal 127,IntegerVal 128,IntegerVal 255,IntegerVal 221,IntegerVal 128,IntegerVal 39,IntegerVal 255,IntegerVal 128,IntegerVal 0,IntegerVal 255]]], start_saturated = False}";
      int reported = 0;
      arg2.val[0] = vcombine_u8(vcreate_u8(UINT64_C(0x003200007f00ff00)),
                                vcreate_u8(UINT64_C(0x80ff7f7f007f677f)));
      arg2.val[1] = vcombine_u8(vcreate_u8(UINT64_C(0x7f7f7f231d808080)),
                                vcreate_u8(UINT64_C(0x0080ab8f88807f80)));
      arg2.val[2] = vcombine_u8(vcreate_u8(UINT64_C(0x00bfff7f7a008080)),
                                vcreate_u8(UINT64_C(0x49000000c0807f80)));
      arg2.val[3] = vcombine_u8(vcreate_u8(UINT64_C(0x807f809100008038)),
                                vcreate_u8(UINT64_C(0xff0080ff2780ddff)));
      clear_neon_saturated();
      vst4q_u8(result, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint8_t got;
         uint8_t exp;
         got = result[0];
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 0 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[1];
         exp = 128U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 1 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[2];
         exp = 128U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 2 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[3];
         exp = 56U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 3 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[4];
         exp = 255U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 4 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[5];
         exp = 128U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 5 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[6];
         exp = 128U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 6 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[7];
         exp = 128U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 7 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[8];
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 8 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[9];
         exp = 128U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 9 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[10];
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 10 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[11];
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 11 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[12];
         exp = 127U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 12 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[13];
         exp = 29U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 13 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[14];
         exp = 122U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 14 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[15];
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 15 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[16];
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 16 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[17];
         exp = 35U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 17 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[18];
         exp = 127U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 18 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[19];
         exp = 145U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 19 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[20];
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 20 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[21];
         exp = 127U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 21 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[22];
         exp = 255U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 22 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[23];
         exp = 128U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 23 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[24];
         exp = 50U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 24 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[25];
         exp = 127U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 25 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[26];
         exp = 191U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 26 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[27];
         exp = 127U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 27 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[28];
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 28 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[29];
         exp = 127U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 29 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[30];
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 30 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[31];
         exp = 128U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 31 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[32];
         exp = 127U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 32 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[33];
         exp = 128U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 33 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[34];
         exp = 128U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 34 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[35];
         exp = 255U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 35 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[36];
         exp = 103U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 36 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[37];
         exp = 127U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 37 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[38];
         exp = 127U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 38 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[39];
         exp = 221U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 39 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[40];
         exp = 127U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 40 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[41];
         exp = 128U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 41 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[42];
         exp = 128U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 42 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[43];
         exp = 128U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 43 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[44];
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 44 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[45];
         exp = 136U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 45 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[46];
         exp = 192U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 46 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[47];
         exp = 39U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 47 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[48];
         exp = 127U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 48 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[49];
         exp = 143U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 49 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[50];
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 50 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[51];
         exp = 255U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 51 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[52];
         exp = 127U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 52 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[53];
         exp = 171U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 53 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[54];
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 54 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[55];
         exp = 128U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 55 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[56];
         exp = 255U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 56 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[57];
         exp = 128U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 57 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[58];
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 58 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[59];
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 59 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[60];
         exp = 128U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 60 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[61];
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 61 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[62];
         exp = 73U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 62 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[63];
         exp = 255U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 63 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1631() {

{
   {
      uint16x8x4_t arg2;
      uint16_t result[32];
      char* str1 = "ReproInfo2 {semantics = \"store4\", fnname = \"vst4q_u16\", rettype = \"__transfersize(32) uint16_t *\", argtypes = \"[/* result holder */,uint16x8x4_t]\", vals = [PtrVal [],ArrayVal [VectorVal [IntegerVal 32768,IntegerVal 65535,IntegerVal 32768,IntegerVal 65160,IntegerVal 23853,IntegerVal 65535,IntegerVal 65535,IntegerVal 0],VectorVal [IntegerVal 65535,IntegerVal 31822,IntegerVal 32767,IntegerVal 32768,IntegerVal 65535,IntegerVal 32767,IntegerVal 55759,IntegerVal 16181],VectorVal [IntegerVal 32768,IntegerVal 48012,IntegerVal 32768,IntegerVal 0,IntegerVal 32768,IntegerVal 32767,IntegerVal 32768,IntegerVal 32768],VectorVal [IntegerVal 32768,IntegerVal 59297,IntegerVal 0,IntegerVal 0,IntegerVal 37150,IntegerVal 0,IntegerVal 32768,IntegerVal 0]]], start_saturated = False}";
      int reported = 0;
      arg2.val[0] = vcombine_u16(vcreate_u16(UINT64_C(0xfe888000ffff8000)),
                                 vcreate_u16(UINT64_C(0x0000ffffffff5d2d)));
      arg2.val[1] = vcombine_u16(vcreate_u16(UINT64_C(0x80007fff7c4effff)),
                                 vcreate_u16(UINT64_C(0x3f35d9cf7fffffff)));
      arg2.val[2] = vcombine_u16(vcreate_u16(UINT64_C(0x00008000bb8c8000)),
                                 vcreate_u16(UINT64_C(0x800080007fff8000)));
      arg2.val[3] = vcombine_u16(vcreate_u16(UINT64_C(0x00000000e7a18000)),
                                 vcreate_u16(UINT64_C(0x000080000000911e)));
      clear_neon_saturated();
      vst4q_u16(result, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint16_t got;
         uint16_t exp;
         got = result[0];
         exp = 32768U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 0 ",
                      exp,
                      got);
            }
      }
      {
         uint16_t got;
         uint16_t exp;
         got = result[1];
         exp = 65535U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 1 ",
                      exp,
                      got);
            }
      }
      {
         uint16_t got;
         uint16_t exp;
         got = result[2];
         exp = 32768U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 2 ",
                      exp,
                      got);
            }
      }
      {
         uint16_t got;
         uint16_t exp;
         got = result[3];
         exp = 32768U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 3 ",
                      exp,
                      got);
            }
      }
      {
         uint16_t got;
         uint16_t exp;
         got = result[4];
         exp = 65535U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 4 ",
                      exp,
                      got);
            }
      }
      {
         uint16_t got;
         uint16_t exp;
         got = result[5];
         exp = 31822U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 5 ",
                      exp,
                      got);
            }
      }
      {
         uint16_t got;
         uint16_t exp;
         got = result[6];
         exp = 48012U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 6 ",
                      exp,
                      got);
            }
      }
      {
         uint16_t got;
         uint16_t exp;
         got = result[7];
         exp = 59297U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 7 ",
                      exp,
                      got);
            }
      }
      {
         uint16_t got;
         uint16_t exp;
         got = result[8];
         exp = 32768U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 8 ",
                      exp,
                      got);
            }
      }
      {
         uint16_t got;
         uint16_t exp;
         got = result[9];
         exp = 32767U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 9 ",
                      exp,
                      got);
            }
      }
      {
         uint16_t got;
         uint16_t exp;
         got = result[10];
         exp = 32768U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 10 ",
                      exp,
                      got);
            }
      }
      {
         uint16_t got;
         uint16_t exp;
         got = result[11];
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 11 ",
                      exp,
                      got);
            }
      }
      {
         uint16_t got;
         uint16_t exp;
         got = result[12];
         exp = 65160U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 12 ",
                      exp,
                      got);
            }
      }
      {
         uint16_t got;
         uint16_t exp;
         got = result[13];
         exp = 32768U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 13 ",
                      exp,
                      got);
            }
      }
      {
         uint16_t got;
         uint16_t exp;
         got = result[14];
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 14 ",
                      exp,
                      got);
            }
      }
      {
         uint16_t got;
         uint16_t exp;
         got = result[15];
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 15 ",
                      exp,
                      got);
            }
      }
      {
         uint16_t got;
         uint16_t exp;
         got = result[16];
         exp = 23853U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 16 ",
                      exp,
                      got);
            }
      }
      {
         uint16_t got;
         uint16_t exp;
         got = result[17];
         exp = 65535U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 17 ",
                      exp,
                      got);
            }
      }
      {
         uint16_t got;
         uint16_t exp;
         got = result[18];
         exp = 32768U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 18 ",
                      exp,
                      got);
            }
      }
      {
         uint16_t got;
         uint16_t exp;
         got = result[19];
         exp = 37150U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 19 ",
                      exp,
                      got);
            }
      }
      {
         uint16_t got;
         uint16_t exp;
         got = result[20];
         exp = 65535U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 20 ",
                      exp,
                      got);
            }
      }
      {
         uint16_t got;
         uint16_t exp;
         got = result[21];
         exp = 32767U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 21 ",
                      exp,
                      got);
            }
      }
      {
         uint16_t got;
         uint16_t exp;
         got = result[22];
         exp = 32767U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 22 ",
                      exp,
                      got);
            }
      }
      {
         uint16_t got;
         uint16_t exp;
         got = result[23];
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 23 ",
                      exp,
                      got);
            }
      }
      {
         uint16_t got;
         uint16_t exp;
         got = result[24];
         exp = 65535U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 24 ",
                      exp,
                      got);
            }
      }
      {
         uint16_t got;
         uint16_t exp;
         got = result[25];
         exp = 55759U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 25 ",
                      exp,
                      got);
            }
      }
      {
         uint16_t got;
         uint16_t exp;
         got = result[26];
         exp = 32768U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 26 ",
                      exp,
                      got);
            }
      }
      {
         uint16_t got;
         uint16_t exp;
         got = result[27];
         exp = 32768U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 27 ",
                      exp,
                      got);
            }
      }
      {
         uint16_t got;
         uint16_t exp;
         got = result[28];
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 28 ",
                      exp,
                      got);
            }
      }
      {
         uint16_t got;
         uint16_t exp;
         got = result[29];
         exp = 16181U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 29 ",
                      exp,
                      got);
            }
      }
      {
         uint16_t got;
         uint16_t exp;
         got = result[30];
         exp = 32768U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 30 ",
                      exp,
                      got);
            }
      }
      {
         uint16_t got;
         uint16_t exp;
         got = result[31];
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 31 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1632() {

{
   {
      uint32x4x4_t arg2;
      uint32_t result[16];
      char* str1 = "ReproInfo2 {semantics = \"store4\", fnname = \"vst4q_u32\", rettype = \"__transfersize(16) uint32_t *\", argtypes = \"[/* result holder */,uint32x4x4_t]\", vals = [PtrVal [],ArrayVal [VectorVal [IntegerVal 2147418112,IntegerVal 4294967295,IntegerVal 2147483648,IntegerVal 4230053887],VectorVal [IntegerVal 32768,IntegerVal 4294948266,IntegerVal 65535,IntegerVal 2147549183],VectorVal [IntegerVal 4294934527,IntegerVal 2147546457,IntegerVal 2147516416,IntegerVal 2147418112],VectorVal [IntegerVal 2147516415,IntegerVal 2147516415,IntegerVal 2147483648,IntegerVal 2147483647]]], start_saturated = False}";
      int reported = 0;
      arg2.val[0] = vcombine_u32(vcreate_u32(UINT64_C(0xffffffff7fff0000)),
                                 vcreate_u32(UINT64_C(0xfc217fff80000000)));
      arg2.val[1] = vcombine_u32(vcreate_u32(UINT64_C(0xffffb5aa00008000)),
                                 vcreate_u32(UINT64_C(0x8000ffff0000ffff)));
      arg2.val[2] = vcombine_u32(vcreate_u32(UINT64_C(0x8000f559ffff7fff)),
                                 vcreate_u32(UINT64_C(0x7fff000080008000)));
      arg2.val[3] = vcombine_u32(vcreate_u32(UINT64_C(0x80007fff80007fff)),
                                 vcreate_u32(UINT64_C(0x7fffffff80000000)));
      clear_neon_saturated();
      vst4q_u32(result, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint32_t got;
         uint32_t exp;
         got = result[0];
         exp = 2147418112U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu32 " Got: %" PRIu32 "\n",
                      "   Elem 0 ",
                      exp,
                      got);
            }
      }
      {
         uint32_t got;
         uint32_t exp;
         got = result[1];
         exp = 32768U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu32 " Got: %" PRIu32 "\n",
                      "   Elem 1 ",
                      exp,
                      got);
            }
      }
      {
         uint32_t got;
         uint32_t exp;
         got = result[2];
         exp = 4294934527U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu32 " Got: %" PRIu32 "\n",
                      "   Elem 2 ",
                      exp,
                      got);
            }
      }
      {
         uint32_t got;
         uint32_t exp;
         got = result[3];
         exp = 2147516415U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu32 " Got: %" PRIu32 "\n",
                      "   Elem 3 ",
                      exp,
                      got);
            }
      }
      {
         uint32_t got;
         uint32_t exp;
         got = result[4];
         exp = 4294967295U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu32 " Got: %" PRIu32 "\n",
                      "   Elem 4 ",
                      exp,
                      got);
            }
      }
      {
         uint32_t got;
         uint32_t exp;
         got = result[5];
         exp = 4294948266U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu32 " Got: %" PRIu32 "\n",
                      "   Elem 5 ",
                      exp,
                      got);
            }
      }
      {
         uint32_t got;
         uint32_t exp;
         got = result[6];
         exp = 2147546457U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu32 " Got: %" PRIu32 "\n",
                      "   Elem 6 ",
                      exp,
                      got);
            }
      }
      {
         uint32_t got;
         uint32_t exp;
         got = result[7];
         exp = 2147516415U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu32 " Got: %" PRIu32 "\n",
                      "   Elem 7 ",
                      exp,
                      got);
            }
      }
      {
         uint32_t got;
         uint32_t exp;
         got = result[8];
         exp = 2147483648U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu32 " Got: %" PRIu32 "\n",
                      "   Elem 8 ",
                      exp,
                      got);
            }
      }
      {
         uint32_t got;
         uint32_t exp;
         got = result[9];
         exp = 65535U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu32 " Got: %" PRIu32 "\n",
                      "   Elem 9 ",
                      exp,
                      got);
            }
      }
      {
         uint32_t got;
         uint32_t exp;
         got = result[10];
         exp = 2147516416U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu32 " Got: %" PRIu32 "\n",
                      "   Elem 10 ",
                      exp,
                      got);
            }
      }
      {
         uint32_t got;
         uint32_t exp;
         got = result[11];
         exp = 2147483648U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu32 " Got: %" PRIu32 "\n",
                      "   Elem 11 ",
                      exp,
                      got);
            }
      }
      {
         uint32_t got;
         uint32_t exp;
         got = result[12];
         exp = 4230053887U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu32 " Got: %" PRIu32 "\n",
                      "   Elem 12 ",
                      exp,
                      got);
            }
      }
      {
         uint32_t got;
         uint32_t exp;
         got = result[13];
         exp = 2147549183U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu32 " Got: %" PRIu32 "\n",
                      "   Elem 13 ",
                      exp,
                      got);
            }
      }
      {
         uint32_t got;
         uint32_t exp;
         got = result[14];
         exp = 2147418112U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu32 " Got: %" PRIu32 "\n",
                      "   Elem 14 ",
                      exp,
                      got);
            }
      }
      {
         uint32_t got;
         uint32_t exp;
         got = result[15];
         exp = 2147483647U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu32 " Got: %" PRIu32 "\n",
                      "   Elem 15 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1633() {

{
   {
      uint64x2x4_t arg2;
      uint64_t result[8];
      char* str1 = "ReproInfo2 {semantics = \"store4\", fnname = \"vst4q_u64\", rettype = \"__transfersize(8) uint64_t *\", argtypes = \"[/* result holder */,uint64x2x4_t]\", vals = [PtrVal [],ArrayVal [VectorVal [IntegerVal 13057342696778137600,IntegerVal 140739635806208],VectorVal [IntegerVal 13774400195653500928,IntegerVal 18446462598854639615],VectorVal [IntegerVal 9223512771966140415,IntegerVal 140733193388032],VectorVal [IntegerVal 9983213738632708096,IntegerVal 9223231297218904063]]], start_saturated = False}";
      int reported = 0;
      arg2.val[0] = vcombine_u64(vcreate_u64(UINT64_C(0xb535000080008000)),
                                 vcreate_u64(UINT64_C(0x000080007fff8000)));
      arg2.val[1] = vcombine_u64(vcreate_u64(UINT64_C(0xbf287fff7fff8000)),
                                 vcreate_u64(UINT64_C(0xffff000007427fff)));
      arg2.val[2] = vcombine_u64(vcreate_u64(UINT64_C(0x80007fff7251ffff)),
                                 vcreate_u64(UINT64_C(0x00007fff00000000)));
      arg2.val[3] = vcombine_u64(vcreate_u64(UINT64_C(0x8a8b800080008000)),
                                 vcreate_u64(UINT64_C(0x7fff7fff7fff7fff)));
      clear_neon_saturated();
      vst4q_u64(result, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = result[0];
         exp = UINT64_C(0xb535000080008000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Elem 0 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = result[1];
         exp = UINT64_C(0xbf287fff7fff8000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Elem 1 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = result[2];
         exp = UINT64_C(0x80007fff7251ffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Elem 2 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = result[3];
         exp = UINT64_C(0x8a8b800080008000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Elem 3 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = result[4];
         exp = UINT64_C(0x000080007fff8000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Elem 4 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = result[5];
         exp = UINT64_C(0xffff000007427fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Elem 5 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = result[6];
         exp = UINT64_C(0x00007fff00000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Elem 6 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = result[7];
         exp = UINT64_C(0x7fff7fff7fff7fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Elem 7 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1634() {

{
   {
      int8x16x4_t arg2;
      int8_t result[64];
      char* str1 = "ReproInfo2 {semantics = \"store4\", fnname = \"vst4q_s8\", rettype = \"__transfersize(64) int8_t *\", argtypes = \"[/* result holder */,int8x16x4_t]\", vals = [PtrVal [],ArrayVal [VectorVal [IntegerVal (-1),IntegerVal 0,IntegerVal (-128),IntegerVal 127,IntegerVal (-128),IntegerVal (-1),IntegerVal (-1),IntegerVal (-128),IntegerVal (-128),IntegerVal (-1),IntegerVal (-128),IntegerVal (-97),IntegerVal (-17),IntegerVal (-128),IntegerVal 64,IntegerVal 127],VectorVal [IntegerVal 29,IntegerVal 0,IntegerVal (-1),IntegerVal (-128),IntegerVal (-1),IntegerVal (-1),IntegerVal 127,IntegerVal 127,IntegerVal (-1),IntegerVal (-10),IntegerVal 0,IntegerVal 127,IntegerVal (-1),IntegerVal 0,IntegerVal 32,IntegerVal (-1)],VectorVal [IntegerVal 0,IntegerVal 61,IntegerVal 127,IntegerVal 127,IntegerVal 127,IntegerVal (-128),IntegerVal 0,IntegerVal 127,IntegerVal (-128),IntegerVal 0,IntegerVal (-128),IntegerVal (-80),IntegerVal 127,IntegerVal 0,IntegerVal 127,IntegerVal (-1)],VectorVal [IntegerVal 0,IntegerVal 0,IntegerVal (-1),IntegerVal 127,IntegerVal (-57),IntegerVal (-128),IntegerVal (-128),IntegerVal 20,IntegerVal (-1),IntegerVal (-128),IntegerVal (-123),IntegerVal 122,IntegerVal (-128),IntegerVal 127,IntegerVal (-128),IntegerVal (-1)]]], start_saturated = False}";
      int reported = 0;
      arg2.val[0] = vcombine_s8(vcreate_s8(UINT64_C(0x80ffff807f8000ff)),
                                vcreate_s8(UINT64_C(0x7f4080ef9f80ff80)));
      arg2.val[1] = vcombine_s8(vcreate_s8(UINT64_C(0x7f7fffff80ff001d)),
                                vcreate_s8(UINT64_C(0xff2000ff7f00f6ff)));
      arg2.val[2] = vcombine_s8(vcreate_s8(UINT64_C(0x7f00807f7f7f3d00)),
                                vcreate_s8(UINT64_C(0xff7f007fb0800080)));
      arg2.val[3] = vcombine_s8(vcreate_s8(UINT64_C(0x148080c77fff0000)),
                                vcreate_s8(UINT64_C(0xff807f807a8580ff)));
      clear_neon_saturated();
      vst4q_s8(result, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         int8_t got;
         int8_t exp;
         got = result[0];
         exp = -1;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 0 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[1];
         exp = 29;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 1 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[2];
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 2 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[3];
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 3 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[4];
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 4 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[5];
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 5 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[6];
         exp = 61;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 6 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[7];
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 7 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[8];
         exp = -128;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 8 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[9];
         exp = -1;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 9 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[10];
         exp = 127;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 10 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[11];
         exp = -1;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 11 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[12];
         exp = 127;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 12 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[13];
         exp = -128;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 13 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[14];
         exp = 127;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 14 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[15];
         exp = 127;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 15 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[16];
         exp = -128;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 16 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[17];
         exp = -1;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 17 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[18];
         exp = 127;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 18 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[19];
         exp = -57;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 19 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[20];
         exp = -1;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 20 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[21];
         exp = -1;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 21 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[22];
         exp = -128;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 22 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[23];
         exp = -128;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 23 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[24];
         exp = -1;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 24 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[25];
         exp = 127;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 25 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[26];
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 26 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[27];
         exp = -128;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 27 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[28];
         exp = -128;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 28 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[29];
         exp = 127;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 29 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[30];
         exp = 127;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 30 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[31];
         exp = 20;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 31 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[32];
         exp = -128;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 32 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[33];
         exp = -1;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 33 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[34];
         exp = -128;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 34 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[35];
         exp = -1;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 35 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[36];
         exp = -1;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 36 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[37];
         exp = -10;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 37 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[38];
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 38 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[39];
         exp = -128;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 39 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[40];
         exp = -128;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 40 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[41];
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 41 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[42];
         exp = -128;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 42 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[43];
         exp = -123;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 43 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[44];
         exp = -97;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 44 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[45];
         exp = 127;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 45 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[46];
         exp = -80;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 46 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[47];
         exp = 122;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 47 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[48];
         exp = -17;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 48 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[49];
         exp = -1;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 49 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[50];
         exp = 127;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 50 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[51];
         exp = -128;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 51 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[52];
         exp = -128;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 52 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[53];
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 53 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[54];
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 54 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[55];
         exp = 127;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 55 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[56];
         exp = 64;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 56 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[57];
         exp = 32;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 57 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[58];
         exp = 127;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 58 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[59];
         exp = -128;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 59 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[60];
         exp = 127;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 60 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[61];
         exp = -1;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 61 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[62];
         exp = -1;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 62 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[63];
         exp = -1;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 63 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1635() {

{
   {
      int16x8x4_t arg2;
      int16_t result[32];
      char* str1 = "ReproInfo2 {semantics = \"store4\", fnname = \"vst4q_s16\", rettype = \"__transfersize(32) int16_t *\", argtypes = \"[/* result holder */,int16x8x4_t]\", vals = [PtrVal [],ArrayVal [VectorVal [IntegerVal 0,IntegerVal (-32768),IntegerVal (-1),IntegerVal (-32768),IntegerVal (-1),IntegerVal (-1),IntegerVal (-32768),IntegerVal (-28492)],VectorVal [IntegerVal (-1),IntegerVal 0,IntegerVal (-1),IntegerVal 10182,IntegerVal (-29115),IntegerVal 0,IntegerVal (-12156),IntegerVal (-1)],VectorVal [IntegerVal 0,IntegerVal 32767,IntegerVal (-1),IntegerVal 14913,IntegerVal (-32768),IntegerVal 8189,IntegerVal (-32768),IntegerVal 0],VectorVal [IntegerVal (-32768),IntegerVal (-32768),IntegerVal (-1),IntegerVal 0,IntegerVal (-1),IntegerVal 0,IntegerVal (-1),IntegerVal (-32768)]]], start_saturated = False}";
      int reported = 0;
      arg2.val[0] = vcombine_s16(vcreate_s16(UINT64_C(0x8000ffff80000000)),
                                 vcreate_s16(UINT64_C(0x90b48000ffffffff)));
      arg2.val[1] = vcombine_s16(vcreate_s16(UINT64_C(0x27c6ffff0000ffff)),
                                 vcreate_s16(UINT64_C(0xffffd08400008e45)));
      arg2.val[2] = vcombine_s16(vcreate_s16(UINT64_C(0x3a41ffff7fff0000)),
                                 vcreate_s16(UINT64_C(0x000080001ffd8000)));
      arg2.val[3] = vcombine_s16(vcreate_s16(UINT64_C(0x0000ffff80008000)),
                                 vcreate_s16(UINT64_C(0x8000ffff0000ffff)));
      clear_neon_saturated();
      vst4q_s16(result, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         int16_t got;
         int16_t exp;
         got = result[0];
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi16 " Got: %" PRIi16 "\n",
                      "   Elem 0 ",
                      exp,
                      got);
            }
      }
      {
         int16_t got;
         int16_t exp;
         got = result[1];
         exp = -1;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi16 " Got: %" PRIi16 "\n",
                      "   Elem 1 ",
                      exp,
                      got);
            }
      }
      {
         int16_t got;
         int16_t exp;
         got = result[2];
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi16 " Got: %" PRIi16 "\n",
                      "   Elem 2 ",
                      exp,
                      got);
            }
      }
      {
         int16_t got;
         int16_t exp;
         got = result[3];
         exp = -32768;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi16 " Got: %" PRIi16 "\n",
                      "   Elem 3 ",
                      exp,
                      got);
            }
      }
      {
         int16_t got;
         int16_t exp;
         got = result[4];
         exp = -32768;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi16 " Got: %" PRIi16 "\n",
                      "   Elem 4 ",
                      exp,
                      got);
            }
      }
      {
         int16_t got;
         int16_t exp;
         got = result[5];
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi16 " Got: %" PRIi16 "\n",
                      "   Elem 5 ",
                      exp,
                      got);
            }
      }
      {
         int16_t got;
         int16_t exp;
         got = result[6];
         exp = 32767;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi16 " Got: %" PRIi16 "\n",
                      "   Elem 6 ",
                      exp,
                      got);
            }
      }
      {
         int16_t got;
         int16_t exp;
         got = result[7];
         exp = -32768;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi16 " Got: %" PRIi16 "\n",
                      "   Elem 7 ",
                      exp,
                      got);
            }
      }
      {
         int16_t got;
         int16_t exp;
         got = result[8];
         exp = -1;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi16 " Got: %" PRIi16 "\n",
                      "   Elem 8 ",
                      exp,
                      got);
            }
      }
      {
         int16_t got;
         int16_t exp;
         got = result[9];
         exp = -1;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi16 " Got: %" PRIi16 "\n",
                      "   Elem 9 ",
                      exp,
                      got);
            }
      }
      {
         int16_t got;
         int16_t exp;
         got = result[10];
         exp = -1;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi16 " Got: %" PRIi16 "\n",
                      "   Elem 10 ",
                      exp,
                      got);
            }
      }
      {
         int16_t got;
         int16_t exp;
         got = result[11];
         exp = -1;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi16 " Got: %" PRIi16 "\n",
                      "   Elem 11 ",
                      exp,
                      got);
            }
      }
      {
         int16_t got;
         int16_t exp;
         got = result[12];
         exp = -32768;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi16 " Got: %" PRIi16 "\n",
                      "   Elem 12 ",
                      exp,
                      got);
            }
      }
      {
         int16_t got;
         int16_t exp;
         got = result[13];
         exp = 10182;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi16 " Got: %" PRIi16 "\n",
                      "   Elem 13 ",
                      exp,
                      got);
            }
      }
      {
         int16_t got;
         int16_t exp;
         got = result[14];
         exp = 14913;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi16 " Got: %" PRIi16 "\n",
                      "   Elem 14 ",
                      exp,
                      got);
            }
      }
      {
         int16_t got;
         int16_t exp;
         got = result[15];
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi16 " Got: %" PRIi16 "\n",
                      "   Elem 15 ",
                      exp,
                      got);
            }
      }
      {
         int16_t got;
         int16_t exp;
         got = result[16];
         exp = -1;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi16 " Got: %" PRIi16 "\n",
                      "   Elem 16 ",
                      exp,
                      got);
            }
      }
      {
         int16_t got;
         int16_t exp;
         got = result[17];
         exp = -29115;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi16 " Got: %" PRIi16 "\n",
                      "   Elem 17 ",
                      exp,
                      got);
            }
      }
      {
         int16_t got;
         int16_t exp;
         got = result[18];
         exp = -32768;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi16 " Got: %" PRIi16 "\n",
                      "   Elem 18 ",
                      exp,
                      got);
            }
      }
      {
         int16_t got;
         int16_t exp;
         got = result[19];
         exp = -1;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi16 " Got: %" PRIi16 "\n",
                      "   Elem 19 ",
                      exp,
                      got);
            }
      }
      {
         int16_t got;
         int16_t exp;
         got = result[20];
         exp = -1;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi16 " Got: %" PRIi16 "\n",
                      "   Elem 20 ",
                      exp,
                      got);
            }
      }
      {
         int16_t got;
         int16_t exp;
         got = result[21];
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi16 " Got: %" PRIi16 "\n",
                      "   Elem 21 ",
                      exp,
                      got);
            }
      }
      {
         int16_t got;
         int16_t exp;
         got = result[22];
         exp = 8189;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi16 " Got: %" PRIi16 "\n",
                      "   Elem 22 ",
                      exp,
                      got);
            }
      }
      {
         int16_t got;
         int16_t exp;
         got = result[23];
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi16 " Got: %" PRIi16 "\n",
                      "   Elem 23 ",
                      exp,
                      got);
            }
      }
      {
         int16_t got;
         int16_t exp;
         got = result[24];
         exp = -32768;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi16 " Got: %" PRIi16 "\n",
                      "   Elem 24 ",
                      exp,
                      got);
            }
      }
      {
         int16_t got;
         int16_t exp;
         got = result[25];
         exp = -12156;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi16 " Got: %" PRIi16 "\n",
                      "   Elem 25 ",
                      exp,
                      got);
            }
      }
      {
         int16_t got;
         int16_t exp;
         got = result[26];
         exp = -32768;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi16 " Got: %" PRIi16 "\n",
                      "   Elem 26 ",
                      exp,
                      got);
            }
      }
      {
         int16_t got;
         int16_t exp;
         got = result[27];
         exp = -1;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi16 " Got: %" PRIi16 "\n",
                      "   Elem 27 ",
                      exp,
                      got);
            }
      }
      {
         int16_t got;
         int16_t exp;
         got = result[28];
         exp = -28492;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi16 " Got: %" PRIi16 "\n",
                      "   Elem 28 ",
                      exp,
                      got);
            }
      }
      {
         int16_t got;
         int16_t exp;
         got = result[29];
         exp = -1;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi16 " Got: %" PRIi16 "\n",
                      "   Elem 29 ",
                      exp,
                      got);
            }
      }
      {
         int16_t got;
         int16_t exp;
         got = result[30];
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi16 " Got: %" PRIi16 "\n",
                      "   Elem 30 ",
                      exp,
                      got);
            }
      }
      {
         int16_t got;
         int16_t exp;
         got = result[31];
         exp = -32768;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi16 " Got: %" PRIi16 "\n",
                      "   Elem 31 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1636() {

{
   {
      int32x4x4_t arg2;
      int32_t result[16];
      char* str1 = "ReproInfo2 {semantics = \"store4\", fnname = \"vst4q_s32\", rettype = \"__transfersize(16) int32_t *\", argtypes = \"[/* result holder */,int32x4x4_t]\", vals = [PtrVal [],ArrayVal [VectorVal [IntegerVal 2147418112,IntegerVal (-2147483648),IntegerVal (-2147450880),IntegerVal (-32768)],VectorVal [IntegerVal (-32768),IntegerVal (-524353536),IntegerVal 2147483647,IntegerVal 32768],VectorVal [IntegerVal (-31548),IntegerVal 2147450879,IntegerVal (-32768),IntegerVal 2147450879],VectorVal [IntegerVal (-1301020673),IntegerVal (-2147450881),IntegerVal (-2147483648),IntegerVal 2147464667]]], start_saturated = False}";
      int reported = 0;
      arg2.val[0] = vcombine_s32(vcreate_s32(UINT64_C(0x800000007fff0000)),
                                 vcreate_s32(UINT64_C(0xffff800080008000)));
      arg2.val[1] = vcombine_s32(vcreate_s32(UINT64_C(0xe0bf0000ffff8000)),
                                 vcreate_s32(UINT64_C(0x000080007fffffff)));
      arg2.val[2] = vcombine_s32(vcreate_s32(UINT64_C(0x7fff7fffffff84c4)),
                                 vcreate_s32(UINT64_C(0x7fff7fffffff8000)));
      arg2.val[3] = vcombine_s32(vcreate_s32(UINT64_C(0x80007fffb273ffff)),
                                 vcreate_s32(UINT64_C(0x7fffb5db80000000)));
      clear_neon_saturated();
      vst4q_s32(result, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         int32_t got;
         int32_t exp;
         got = result[0];
         exp = 2147418112;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi32 " Got: %" PRIi32 "\n",
                      "   Elem 0 ",
                      exp,
                      got);
            }
      }
      {
         int32_t got;
         int32_t exp;
         got = result[1];
         exp = -32768;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi32 " Got: %" PRIi32 "\n",
                      "   Elem 1 ",
                      exp,
                      got);
            }
      }
      {
         int32_t got;
         int32_t exp;
         got = result[2];
         exp = -31548;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi32 " Got: %" PRIi32 "\n",
                      "   Elem 2 ",
                      exp,
                      got);
            }
      }
      {
         int32_t got;
         int32_t exp;
         got = result[3];
         exp = -1301020673;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi32 " Got: %" PRIi32 "\n",
                      "   Elem 3 ",
                      exp,
                      got);
            }
      }
      {
         int32_t got;
         int32_t exp;
         got = result[4];
         exp = (int32_t) 0x80000000;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi32 " Got: %" PRIi32 "\n",
                      "   Elem 4 ",
                      exp,
                      got);
            }
      }
      {
         int32_t got;
         int32_t exp;
         got = result[5];
         exp = -524353536;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi32 " Got: %" PRIi32 "\n",
                      "   Elem 5 ",
                      exp,
                      got);
            }
      }
      {
         int32_t got;
         int32_t exp;
         got = result[6];
         exp = 2147450879;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi32 " Got: %" PRIi32 "\n",
                      "   Elem 6 ",
                      exp,
                      got);
            }
      }
      {
         int32_t got;
         int32_t exp;
         got = result[7];
         exp = -2147450881;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi32 " Got: %" PRIi32 "\n",
                      "   Elem 7 ",
                      exp,
                      got);
            }
      }
      {
         int32_t got;
         int32_t exp;
         got = result[8];
         exp = -2147450880;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi32 " Got: %" PRIi32 "\n",
                      "   Elem 8 ",
                      exp,
                      got);
            }
      }
      {
         int32_t got;
         int32_t exp;
         got = result[9];
         exp = 2147483647;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi32 " Got: %" PRIi32 "\n",
                      "   Elem 9 ",
                      exp,
                      got);
            }
      }
      {
         int32_t got;
         int32_t exp;
         got = result[10];
         exp = -32768;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi32 " Got: %" PRIi32 "\n",
                      "   Elem 10 ",
                      exp,
                      got);
            }
      }
      {
         int32_t got;
         int32_t exp;
         got = result[11];
         exp = (int32_t) 0x80000000;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi32 " Got: %" PRIi32 "\n",
                      "   Elem 11 ",
                      exp,
                      got);
            }
      }
      {
         int32_t got;
         int32_t exp;
         got = result[12];
         exp = -32768;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi32 " Got: %" PRIi32 "\n",
                      "   Elem 12 ",
                      exp,
                      got);
            }
      }
      {
         int32_t got;
         int32_t exp;
         got = result[13];
         exp = 32768;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi32 " Got: %" PRIi32 "\n",
                      "   Elem 13 ",
                      exp,
                      got);
            }
      }
      {
         int32_t got;
         int32_t exp;
         got = result[14];
         exp = 2147450879;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi32 " Got: %" PRIi32 "\n",
                      "   Elem 14 ",
                      exp,
                      got);
            }
      }
      {
         int32_t got;
         int32_t exp;
         got = result[15];
         exp = 2147464667;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi32 " Got: %" PRIi32 "\n",
                      "   Elem 15 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1637() {

{
   {
      int64x2x4_t arg2;
      int64_t result[8];
      char* str1 = "ReproInfo2 {semantics = \"store4\", fnname = \"vst4q_s64\", rettype = \"__transfersize(8) int64_t *\", argtypes = \"[/* result holder */,int64x2x4_t]\", vals = [PtrVal [],ArrayVal [VectorVal [IntegerVal (-9223218483184041984),IntegerVal 9223284002910093883],VectorVal [IntegerVal 2147457373,IntegerVal 9223231302024855551],VectorVal [IntegerVal 9223090566172999680,IntegerVal 32768],VectorVal [IntegerVal 140735340838911,IntegerVal 191685384667136]]], start_saturated = False}";
      int reported = 0;
      arg2.val[0] = vcombine_s64(vcreate_s64(UINT64_C(0x80008ba7ffff8000)),
                                 vcreate_s64(UINT64_C(0x7fffafeeffffc23b)));
      arg2.val[1] = vcombine_s64(vcreate_s64(UINT64_C(0x000000007fff995d)),
                                 vcreate_s64(UINT64_C(0x7fff80009e747fff)));
      arg2.val[2] = vcombine_s64(vcreate_s64(UINT64_C(0x7fff0000ffff8000)),
                                 vcreate_s64(UINT64_C(0x0000000000008000)));
      arg2.val[3] = vcombine_s64(vcreate_s64(UINT64_C(0x00007fff7fff7fff)),
                                 vcreate_s64(UINT64_C(0x0000ae563b430000)));
      clear_neon_saturated();
      vst4q_s64(result, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         int64_t got;
         int64_t exp;
         got = result[0];
         exp = INT64_C(-9223218483184041984);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi64 " Got: %" PRIi64 "\n",
                      "   Elem 0 ",
                      exp,
                      got);
            }
      }
      {
         int64_t got;
         int64_t exp;
         got = result[1];
         exp = INT64_C(2147457373);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi64 " Got: %" PRIi64 "\n",
                      "   Elem 1 ",
                      exp,
                      got);
            }
      }
      {
         int64_t got;
         int64_t exp;
         got = result[2];
         exp = INT64_C(9223090566172999680);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi64 " Got: %" PRIi64 "\n",
                      "   Elem 2 ",
                      exp,
                      got);
            }
      }
      {
         int64_t got;
         int64_t exp;
         got = result[3];
         exp = INT64_C(140735340838911);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi64 " Got: %" PRIi64 "\n",
                      "   Elem 3 ",
                      exp,
                      got);
            }
      }
      {
         int64_t got;
         int64_t exp;
         got = result[4];
         exp = INT64_C(9223284002910093883);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi64 " Got: %" PRIi64 "\n",
                      "   Elem 4 ",
                      exp,
                      got);
            }
      }
      {
         int64_t got;
         int64_t exp;
         got = result[5];
         exp = INT64_C(9223231302024855551);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi64 " Got: %" PRIi64 "\n",
                      "   Elem 5 ",
                      exp,
                      got);
            }
      }
      {
         int64_t got;
         int64_t exp;
         got = result[6];
         exp = INT64_C(32768);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi64 " Got: %" PRIi64 "\n",
                      "   Elem 6 ",
                      exp,
                      got);
            }
      }
      {
         int64_t got;
         int64_t exp;
         got = result[7];
         exp = INT64_C(191685384667136);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi64 " Got: %" PRIi64 "\n",
                      "   Elem 7 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1638() {

{
   {
      float32x4x4_t arg2;
      float32_t result[16];
      char* str1 = "ReproInfo2 {semantics = \"store4\", fnname = \"vst4q_f32\", rettype = \"__transfersize(16) float32_t *\", argtypes = \"[/* result holder */,float32x4x4_t]\", vals = [PtrVal [],ArrayVal [VectorVal [FloatVal 0.5348364114761353,FloatVal 0.6401283144950867,FloatVal 0.9446695446968079,FloatVal 0.3806597590446472],VectorVal [FloatVal 0.6679015755653381,FloatVal 0.5548200607299805,FloatVal 0.9121193289756775,FloatVal 0.13658630847930908],VectorVal [FloatVal 0.1644267439842224,FloatVal 3.836357593536377e-2,FloatVal 0.3599279522895813,FloatVal 0.38002145290374756],VectorVal [FloatVal 0.24557924270629883,FloatVal 0.5714160203933716,FloatVal 0.6754915118217468,FloatVal 0.9367330074310303]]], start_saturated = False}";
      int reported = 0;
      arg2.val[0] = vcombine_f32(vcreate_f32(UINT64_C(0x3f23df733f08eb0a)),
                                 vcreate_f32(UINT64_C(0x3ec2e5d63f71d5dd)));
      arg2.val[1] = vcombine_f32(vcreate_f32(UINT64_C(0x3f0e08b03f2afb99)),
                                 vcreate_f32(UINT64_C(0x3e0bdd483f6980a7)));
      arg2.val[2] = vcombine_f32(vcreate_f32(UINT64_C(0x3d1d23203e285f7c)),
                                 vcreate_f32(UINT64_C(0x3ec2922c3eb8487a)));
      arg2.val[3] = vcombine_f32(vcreate_f32(UINT64_C(0x3f1248523e7b7920)),
                                 vcreate_f32(UINT64_C(0x3f6fcdbc3f2ced03)));
      clear_neon_saturated();
      vst4q_f32(result, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = result[0];
         exp = ((float32_t) 0.5348364114761353);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 0 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = result[1];
         exp = ((float32_t) 0.6679015755653381);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 1 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = result[2];
         exp = ((float32_t) 0.1644267439842224);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 2 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = result[3];
         exp = ((float32_t) 0.24557924270629883);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 3 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = result[4];
         exp = ((float32_t) 0.6401283144950867);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 4 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = result[5];
         exp = ((float32_t) 0.5548200607299805);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 5 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = result[6];
         exp = ((float32_t) 3.836357593536377e-2);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 6 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = result[7];
         exp = ((float32_t) 0.5714160203933716);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 7 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = result[8];
         exp = ((float32_t) 0.9446695446968079);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 8 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = result[9];
         exp = ((float32_t) 0.9121193289756775);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 9 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = result[10];
         exp = ((float32_t) 0.3599279522895813);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 10 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = result[11];
         exp = ((float32_t) 0.6754915118217468);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 11 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = result[12];
         exp = ((float32_t) 0.3806597590446472);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 12 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = result[13];
         exp = ((float32_t) 0.13658630847930908);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 13 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = result[14];
         exp = ((float32_t) 0.38002145290374756);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 14 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = result[15];
         exp = ((float32_t) 0.9367330074310303);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 15 ", exp, got);
            }
      }
   }
}
}
void dotests_1639() {

{
   {
      float64x2x4_t arg2;
      float64_t result[8];
      char* str1 = "ReproInfo2 {semantics = \"store4\", fnname = \"vst4q_f64\", rettype = \"__transfersize(8) float64_t *\", argtypes = \"[/* result holder */,float64x2x4_t]\", vals = [PtrVal [],ArrayVal [VectorVal [FloatVal 3.989182078656395e-3,FloatVal 0.20692241184214333],VectorVal [FloatVal 0.906796434818126,FloatVal 0.3573011958105109],VectorVal [FloatVal 0.8947062671847156,FloatVal 0.4678100776462917],VectorVal [FloatVal 0.26240161723088806,FloatVal 0.6060229825604433]]], start_saturated = False}";
      int reported = 0;
      arg2.val[0] = vcombine_f64(vcreate_f64(UINT64_C(0x3f7056f5e90cc600)),
                                 vcreate_f64(UINT64_C(0x3fca7c6effd5f208)));
      arg2.val[1] = vcombine_f64(vcreate_f64(UINT64_C(0x3fed0479f4f58b3d)),
                                 vcreate_f64(UINT64_C(0x3fd6de05d5b4fb46)));
      arg2.val[2] = vcombine_f64(vcreate_f64(UINT64_C(0x3feca16f09a2b4f9)),
                                 vcreate_f64(UINT64_C(0x3fddf099ae0eb908)));
      arg2.val[3] = vcombine_f64(vcreate_f64(UINT64_C(0x3fd0cb30271b25ac)),
                                 vcreate_f64(UINT64_C(0x3fe3648a4f571662)));
      clear_neon_saturated();
      vst4q_f64(result, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float64_t got;
         float64_t exp;
         got = result[0];
         exp = 3.989182078656395e-3;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 0 ", exp, got);
            }
      }
      {
         float64_t got;
         float64_t exp;
         got = result[1];
         exp = 0.906796434818126;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 1 ", exp, got);
            }
      }
      {
         float64_t got;
         float64_t exp;
         got = result[2];
         exp = 0.8947062671847156;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 2 ", exp, got);
            }
      }
      {
         float64_t got;
         float64_t exp;
         got = result[3];
         exp = 0.26240161723088806;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 3 ", exp, got);
            }
      }
      {
         float64_t got;
         float64_t exp;
         got = result[4];
         exp = 0.20692241184214333;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 4 ", exp, got);
            }
      }
      {
         float64_t got;
         float64_t exp;
         got = result[5];
         exp = 0.3573011958105109;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 5 ", exp, got);
            }
      }
      {
         float64_t got;
         float64_t exp;
         got = result[6];
         exp = 0.4678100776462917;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 6 ", exp, got);
            }
      }
      {
         float64_t got;
         float64_t exp;
         got = result[7];
         exp = 0.6060229825604433;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 7 ", exp, got);
            }
      }
   }
}
}
void dotests_1640() {

{
   {
      poly8x16x4_t arg2;
      poly8_t result[64];
      char* str1 = "ReproInfo2 {semantics = \"store4\", fnname = \"vst4q_p8\", rettype = \"__transfersize(64) poly8_t *\", argtypes = \"[/* result holder */,poly8x16x4_t]\", vals = [PtrVal [],ArrayVal [VectorVal [PolyVal [0,0,0,1,1,0,0,1],PolyVal [0,1,1,0,0,1,1,1],PolyVal [0,1,1,0,0,1,1,0],PolyVal [1,1,1,0,0,1,0,0],PolyVal [1,0,1,1,1,0,1,1],PolyVal [1,0,0,0,0,0,1,1],PolyVal [0,1,1,0,0,1,1,0],PolyVal [0,1,1,1,1,1,1,1],PolyVal [1,0,1,1,0,0,0,0],PolyVal [0,0,0,1,0,0,0,1],PolyVal [1,1,1,0,0,0,1,0],PolyVal [0,1,0,1,1,0,0,0],PolyVal [1,0,1,1,1,1,1,0],PolyVal [1,0,0,0,0,1,1,0],PolyVal [0,1,1,0,0,0,0,0],PolyVal [1,1,0,0,0,0,1,1]],VectorVal [PolyVal [1,1,0,0,0,1,0,1],PolyVal [1,1,1,1,1,0,1,1],PolyVal [1,1,1,1,0,1,0,0],PolyVal [0,0,0,1,1,1,0,1],PolyVal [1,1,1,1,1,0,0,0],PolyVal [0,0,1,0,1,0,1,1],PolyVal [1,1,1,0,0,0,1,0],PolyVal [0,1,0,0,1,0,1,1],PolyVal [0,0,0,1,0,1,1,0],PolyVal [0,1,1,0,0,1,1,1],PolyVal [0,1,1,0,1,0,0,1],PolyVal [0,0,1,1,1,0,1,1],PolyVal [1,1,0,1,1,0,0,0],PolyVal [1,1,1,1,1,0,0,1],PolyVal [1,1,0,1,0,1,1,0],PolyVal [0,1,1,1,1,1,1,1]],VectorVal [PolyVal [1,1,1,1,0,0,1,0],PolyVal [1,0,0,0,1,0,0,0],PolyVal [0,0,0,0,0,0,1,1],PolyVal [0,1,0,0,1,0,0,0],PolyVal [0,0,1,0,0,0,0,0],PolyVal [1,1,0,0,1,0,0,1],PolyVal [0,0,0,0,1,1,1,1],PolyVal [1,0,1,0,1,0,1,1],PolyVal [1,0,1,0,1,1,1,1],PolyVal [1,0,1,1,0,0,0,1],PolyVal [0,1,1,0,1,0,1,0],PolyVal [0,1,1,1,0,0,0,0],PolyVal [0,0,0,0,0,1,1,1],PolyVal [0,0,1,0,1,0,1,0],PolyVal [0,0,1,0,1,1,0,0],PolyVal [1,1,0,0,1,1,0,1]],VectorVal [PolyVal [0,0,0,0,1,1,0,1],PolyVal [0,1,1,1,1,1,0,1],PolyVal [0,1,0,1,0,1,0,1],PolyVal [1,0,0,0,0,1,0,0],PolyVal [1,1,1,1,0,0,1,1],PolyVal [0,1,1,0,0,0,1,0],PolyVal [1,0,1,0,0,1,1,0],PolyVal [1,0,0,0,1,1,1,1],PolyVal [1,0,0,0,1,0,1,0],PolyVal [0,1,0,0,0,1,0,1],PolyVal [0,0,0,0,1,0,0,1],PolyVal [1,0,1,1,0,0,0,1],PolyVal [0,1,0,0,0,0,0,0],PolyVal [0,1,1,1,0,1,1,0],PolyVal [1,1,1,0,1,1,1,1],PolyVal [1,0,0,0,1,0,1,1]]]], start_saturated = False}";
      int reported = 0;
      arg2.val[0] = vcombine_p8(vcreate_p8(UINT64_C(0xfe66c1dd2766e698)),
                                vcreate_p8(UINT64_C(0xc306617d1a47880d)));
      arg2.val[1] = vcombine_p8(vcreate_p8(UINT64_C(0xd247d41fb82fdfa3)),
                                vcreate_p8(UINT64_C(0xfe6b9f1bdc96e668)));
      arg2.val[2] = vcombine_p8(vcreate_p8(UINT64_C(0xd5f0930412c0114f)),
                                vcreate_p8(UINT64_C(0xb33454e00e568df5)));
      arg2.val[3] = vcombine_p8(vcreate_p8(UINT64_C(0xf16546cf21aabeb0)),
                                vcreate_p8(UINT64_C(0xd1f76e028d90a251)));
      clear_neon_saturated();
      vst4q_p8(result, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         poly8_t got;
         poly8_t exp;
         got = result[0];
         exp = 152;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 0 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[1];
         exp = 163;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 1 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[2];
         exp = 79;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 2 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[3];
         exp = 176;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 3 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[4];
         exp = 230;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 4 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[5];
         exp = 223;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 5 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[6];
         exp = 17;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 6 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[7];
         exp = 190;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 7 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[8];
         exp = 102;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 8 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[9];
         exp = 47;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 9 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[10];
         exp = 192;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 10 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[11];
         exp = 170;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 11 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[12];
         exp = 39;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 12 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[13];
         exp = 184;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 13 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[14];
         exp = 18;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 14 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[15];
         exp = 33;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 15 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[16];
         exp = 221;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 16 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[17];
         exp = 31;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 17 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[18];
         exp = 4;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 18 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[19];
         exp = 207;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 19 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[20];
         exp = 193;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 20 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[21];
         exp = 212;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 21 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[22];
         exp = 147;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 22 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[23];
         exp = 70;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 23 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[24];
         exp = 102;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 24 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[25];
         exp = 71;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 25 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[26];
         exp = 240;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 26 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[27];
         exp = 101;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 27 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[28];
         exp = 254;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 28 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[29];
         exp = 210;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 29 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[30];
         exp = 213;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 30 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[31];
         exp = 241;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 31 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[32];
         exp = 13;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 32 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[33];
         exp = 104;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 33 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[34];
         exp = 245;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 34 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[35];
         exp = 81;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 35 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[36];
         exp = 136;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 36 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[37];
         exp = 230;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 37 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[38];
         exp = 141;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 38 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[39];
         exp = 162;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 39 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[40];
         exp = 71;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 40 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[41];
         exp = 150;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 41 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[42];
         exp = 86;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 42 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[43];
         exp = 144;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 43 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[44];
         exp = 26;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 44 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[45];
         exp = 220;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 45 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[46];
         exp = 14;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 46 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[47];
         exp = 141;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 47 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[48];
         exp = 125;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 48 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[49];
         exp = 27;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 49 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[50];
         exp = 224;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 50 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[51];
         exp = 2;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 51 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[52];
         exp = 97;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 52 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[53];
         exp = 159;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 53 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[54];
         exp = 84;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 54 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[55];
         exp = 110;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 55 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[56];
         exp = 6;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 56 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[57];
         exp = 107;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 57 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[58];
         exp = 52;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 58 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[59];
         exp = 247;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 59 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[60];
         exp = 195;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 60 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[61];
         exp = 254;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 61 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[62];
         exp = 179;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 62 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[63];
         exp = 209;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 63 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1641() {

{
   {
      poly16x8x4_t arg2;
      poly16_t result[32];
      char* str1 = "ReproInfo2 {semantics = \"store4\", fnname = \"vst4q_p16\", rettype = \"__transfersize(32) poly16_t *\", argtypes = \"[/* result holder */,poly16x8x4_t]\", vals = [PtrVal [],ArrayVal [VectorVal [PolyVal [1,0,0,1,0,0,1,0,0,1,1,0,0,1,1,0],PolyVal [0,0,0,0,1,1,0,1,1,0,0,1,1,0,0,0],PolyVal [0,0,0,1,0,1,1,0,1,1,0,0,1,1,1,1],PolyVal [1,0,1,1,0,1,0,0,1,0,1,0,0,1,0,1],PolyVal [1,1,0,0,0,1,0,0,1,1,1,0,1,1,0,0],PolyVal [0,0,1,0,1,0,0,0,1,0,1,1,0,1,1,1],PolyVal [1,1,0,1,1,1,0,1,0,1,0,0,1,1,1,1],PolyVal [0,0,1,1,1,1,1,1,1,0,0,1,1,1,1,0]],VectorVal [PolyVal [0,0,1,0,0,1,0,1,1,1,0,1,1,1,1,0],PolyVal [0,1,0,1,0,0,1,1,1,0,1,1,0,0,0,1],PolyVal [0,1,1,0,0,0,0,1,0,0,0,0,0,1,0,0],PolyVal [1,1,1,0,0,1,1,0,1,1,0,1,1,1,1,0],PolyVal [1,1,1,1,0,0,1,1,0,0,1,0,1,0,1,0],PolyVal [1,0,1,1,1,0,1,1,1,1,0,1,0,0,0,0],PolyVal [1,0,0,0,0,0,1,0,0,1,1,1,0,0,0,0],PolyVal [1,0,0,1,0,1,0,0,0,1,0,1,1,0,0,0]],VectorVal [PolyVal [0,1,0,1,0,1,1,0,1,0,1,0,1,0,1,1],PolyVal [0,0,1,0,0,1,0,0,1,0,1,1,0,0,1,0],PolyVal [0,1,1,1,1,0,0,0,0,0,0,0,1,0,1,1],PolyVal [0,0,1,0,0,0,1,0,1,1,1,0,1,1,0,1],PolyVal [0,0,0,0,0,0,1,1,1,1,1,1,1,0,1,1],PolyVal [1,0,0,0,0,1,1,1,0,0,0,1,1,1,0,1],PolyVal [0,1,1,1,0,1,0,0,1,1,1,1,0,0,0,0],PolyVal [0,1,0,0,0,0,0,1,0,0,0,0,0,1,0,1]],VectorVal [PolyVal [0,0,0,1,0,0,0,1,1,1,1,1,1,0,0,0],PolyVal [1,1,1,1,0,0,0,1,1,1,0,0,0,0,0,0],PolyVal [0,0,0,0,0,1,0,0,0,1,1,1,1,1,1,1],PolyVal [1,1,0,1,0,0,1,1,1,0,0,1,0,0,1,1],PolyVal [1,1,0,1,0,1,0,1,1,0,1,1,1,0,0,0],PolyVal [0,1,1,1,1,0,1,1,0,0,0,1,0,1,0,1],PolyVal [1,0,0,1,1,0,0,1,1,1,1,1,1,0,0,0],PolyVal [0,1,0,1,1,1,1,0,0,0,0,0,0,0,0,0]]]], start_saturated = False}";
      int reported = 0;
      arg2.val[0] = vcombine_p16(vcreate_p16(UINT64_C(0xa52df36819b06649)),
                                 vcreate_p16(UINT64_C(0x79fcf2bbed143723)));
      arg2.val[1] = vcombine_p16(vcreate_p16(UINT64_C(0x7b6720868dca7ba4)),
                                 vcreate_p16(UINT64_C(0x1a290e410bdd54cf)));
      arg2.val[2] = vcombine_p16(vcreate_p16(UINT64_C(0xb744d01e4d24d56a)),
                                 vcreate_p16(UINT64_C(0xa0820f2eb8e1dfc0)));
      arg2.val[3] = vcombine_p16(vcreate_p16(UINT64_C(0xc9cbfe20038f1f88)),
                                 vcreate_p16(UINT64_C(0x007a1f99a8de1dab)));
      clear_neon_saturated();
      vst4q_p16(result, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         poly16_t got;
         poly16_t exp;
         got = result[0];
         exp = 26185;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 0 ",
                      exp,
                      got);
            }
      }
      {
         poly16_t got;
         poly16_t exp;
         got = result[1];
         exp = 31652;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 1 ",
                      exp,
                      got);
            }
      }
      {
         poly16_t got;
         poly16_t exp;
         got = result[2];
         exp = 54634;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 2 ",
                      exp,
                      got);
            }
      }
      {
         poly16_t got;
         poly16_t exp;
         got = result[3];
         exp = 8072;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 3 ",
                      exp,
                      got);
            }
      }
      {
         poly16_t got;
         poly16_t exp;
         got = result[4];
         exp = 6576;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 4 ",
                      exp,
                      got);
            }
      }
      {
         poly16_t got;
         poly16_t exp;
         got = result[5];
         exp = 36298;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 5 ",
                      exp,
                      got);
            }
      }
      {
         poly16_t got;
         poly16_t exp;
         got = result[6];
         exp = 19748;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 6 ",
                      exp,
                      got);
            }
      }
      {
         poly16_t got;
         poly16_t exp;
         got = result[7];
         exp = 911;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 7 ",
                      exp,
                      got);
            }
      }
      {
         poly16_t got;
         poly16_t exp;
         got = result[8];
         exp = 62312;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 8 ",
                      exp,
                      got);
            }
      }
      {
         poly16_t got;
         poly16_t exp;
         got = result[9];
         exp = 8326;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 9 ",
                      exp,
                      got);
            }
      }
      {
         poly16_t got;
         poly16_t exp;
         got = result[10];
         exp = 53278;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 10 ",
                      exp,
                      got);
            }
      }
      {
         poly16_t got;
         poly16_t exp;
         got = result[11];
         exp = 65056;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 11 ",
                      exp,
                      got);
            }
      }
      {
         poly16_t got;
         poly16_t exp;
         got = result[12];
         exp = 42285;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 12 ",
                      exp,
                      got);
            }
      }
      {
         poly16_t got;
         poly16_t exp;
         got = result[13];
         exp = 31591;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 13 ",
                      exp,
                      got);
            }
      }
      {
         poly16_t got;
         poly16_t exp;
         got = result[14];
         exp = 46916;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 14 ",
                      exp,
                      got);
            }
      }
      {
         poly16_t got;
         poly16_t exp;
         got = result[15];
         exp = 51659;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 15 ",
                      exp,
                      got);
            }
      }
      {
         poly16_t got;
         poly16_t exp;
         got = result[16];
         exp = 14115;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 16 ",
                      exp,
                      got);
            }
      }
      {
         poly16_t got;
         poly16_t exp;
         got = result[17];
         exp = 21711;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 17 ",
                      exp,
                      got);
            }
      }
      {
         poly16_t got;
         poly16_t exp;
         got = result[18];
         exp = 57280;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 18 ",
                      exp,
                      got);
            }
      }
      {
         poly16_t got;
         poly16_t exp;
         got = result[19];
         exp = 7595;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 19 ",
                      exp,
                      got);
            }
      }
      {
         poly16_t got;
         poly16_t exp;
         got = result[20];
         exp = 60692;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 20 ",
                      exp,
                      got);
            }
      }
      {
         poly16_t got;
         poly16_t exp;
         got = result[21];
         exp = 3037;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 21 ",
                      exp,
                      got);
            }
      }
      {
         poly16_t got;
         poly16_t exp;
         got = result[22];
         exp = 47329;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 22 ",
                      exp,
                      got);
            }
      }
      {
         poly16_t got;
         poly16_t exp;
         got = result[23];
         exp = 43230;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 23 ",
                      exp,
                      got);
            }
      }
      {
         poly16_t got;
         poly16_t exp;
         got = result[24];
         exp = 62139;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 24 ",
                      exp,
                      got);
            }
      }
      {
         poly16_t got;
         poly16_t exp;
         got = result[25];
         exp = 3649;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 25 ",
                      exp,
                      got);
            }
      }
      {
         poly16_t got;
         poly16_t exp;
         got = result[26];
         exp = 3886;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 26 ",
                      exp,
                      got);
            }
      }
      {
         poly16_t got;
         poly16_t exp;
         got = result[27];
         exp = 8089;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 27 ",
                      exp,
                      got);
            }
      }
      {
         poly16_t got;
         poly16_t exp;
         got = result[28];
         exp = 31228;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 28 ",
                      exp,
                      got);
            }
      }
      {
         poly16_t got;
         poly16_t exp;
         got = result[29];
         exp = 6697;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 29 ",
                      exp,
                      got);
            }
      }
      {
         poly16_t got;
         poly16_t exp;
         got = result[30];
         exp = 41090;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 30 ",
                      exp,
                      got);
            }
      }
      {
         poly16_t got;
         poly16_t exp;
         got = result[31];
         exp = 122;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 31 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1642() {
#if __ARM_NEON_FP16_INTRINSICS

{
   {
      float16x8x4_t arg2;
      __fp16 result[32];
      char* str1 = "ReproInfo2 {semantics = \"store4\", fnname = \"vst4q_f16\", rettype = \"__transfersize(32) __fp16 *\", argtypes = \"[/* result holder */,float16x8x4_t]\", vals = [PtrVal [],ArrayVal [VectorVal [FloatVal (-4.205717576310901),FloatVal (-0.6265485959331869),FloatVal 3.0201276553227245,FloatVal (-4.818651777395799),FloatVal 8.171854261127315,FloatVal 8.002472141075746,FloatVal (-5.348718021390518),FloatVal (-9.525214874796271)],VectorVal [FloatVal 3.5459562122601938,FloatVal 7.78620837607297,FloatVal (-4.8096837549655325),FloatVal 1.426954692909261,FloatVal (-5.183264367433367),FloatVal (-0.5484609519439037),FloatVal 2.893851910320066,FloatVal 8.792986085576967],VectorVal [FloatVal (-1.5433438742202092),FloatVal (-5.220649114616441),FloatVal 7.190296289050973,FloatVal 8.588495742760724,FloatVal (-1.0639159020607778),FloatVal (-3.7745810996738687),FloatVal 0.9202598069367127,FloatVal (-5.742387569067393)],VectorVal [FloatVal (-5.483022661436512),FloatVal 8.235578566237479,FloatVal (-1.2882901200058878),FloatVal 8.24276709951366,FloatVal 1.3053600217792845,FloatVal (-5.913216343081489),FloatVal 8.398764851745561,FloatVal 2.524248340892555]]], start_saturated = False}";
      int reported = 0;
      arg2.val[0] = vcombine_f16(vcreate_f16(UINT64_C(0xc4d1420ab903c434)),
                                 vcreate_f16(UINT64_C(0xc8c3c55948004815)));
      arg2.val[1] = vcombine_f16(vcreate_f16(UINT64_C(0x3db5c4cf47c94317)),
                                 vcreate_f16(UINT64_C(0x486541c9b863c52e)));
      arg2.val[2] = vcombine_f16(vcreate_f16(UINT64_C(0x484b4730c538be2c)),
                                 vcreate_f16(UINT64_C(0xc5be3b5cc38cbc41)));
      arg2.val[3] = vcombine_f16(vcreate_f16(UINT64_C(0x481fbd27481ec57b)),
                                 vcreate_f16(UINT64_C(0x410c4833c5e93d38)));
      clear_neon_saturated();
      vst4q_f16(result, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         __fp16 got;
         __fp16 exp;
         got = result[0];
         exp = -4.205717576310901;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 0 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = result[1];
         exp = 3.5459562122601938;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 1 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = result[2];
         exp = -1.5433438742202092;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 2 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = result[3];
         exp = -5.483022661436512;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 3 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = result[4];
         exp = -0.6265485959331869;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 4 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = result[5];
         exp = 7.78620837607297;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 5 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = result[6];
         exp = -5.220649114616441;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 6 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = result[7];
         exp = 8.235578566237479;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 7 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = result[8];
         exp = 3.0201276553227245;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 8 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = result[9];
         exp = -4.8096837549655325;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 9 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = result[10];
         exp = 7.190296289050973;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 10 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = result[11];
         exp = -1.2882901200058878;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 11 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = result[12];
         exp = -4.818651777395799;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 12 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = result[13];
         exp = 1.426954692909261;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 13 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = result[14];
         exp = 8.588495742760724;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 14 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = result[15];
         exp = 8.24276709951366;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 15 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = result[16];
         exp = 8.171854261127315;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 16 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = result[17];
         exp = -5.183264367433367;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 17 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = result[18];
         exp = -1.0639159020607778;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 18 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = result[19];
         exp = 1.3053600217792845;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 19 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = result[20];
         exp = 8.002472141075746;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 20 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = result[21];
         exp = -0.5484609519439037;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 21 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = result[22];
         exp = -3.7745810996738687;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 22 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = result[23];
         exp = -5.913216343081489;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 23 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = result[24];
         exp = -5.348718021390518;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 24 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = result[25];
         exp = 2.893851910320066;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 25 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = result[26];
         exp = 0.9202598069367127;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 26 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = result[27];
         exp = 8.398764851745561;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 27 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = result[28];
         exp = -9.525214874796271;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 28 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = result[29];
         exp = 8.792986085576967;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 29 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = result[30];
         exp = -5.742387569067393;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 30 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = result[31];
         exp = 2.524248340892555;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 31 ", exp, got);
            }
      }
   }
}
#endif
}
void dotests_1643() {

{
   {
      poly64x2x4_t arg2;
      poly64_t result[8];
      char* str1 = "ReproInfo2 {semantics = \"store4\", fnname = \"vst4q_p64\", rettype = \"__transfersize(8) poly64_t *\", argtypes = \"[/* result holder */,poly64x2x4_t]\", vals = [PtrVal [],ArrayVal [VectorVal [PolyVal [0,1,0,0,1,0,0,0,1,1,0,0,1,0,1,0,1,0,0,1,1,1,1,1,1,0,0,1,1,0,1,1,0,0,0,0,0,1,0,0,1,1,0,1,1,0,1,0,0,1,0,0,1,1,0,0,1,0,0,1,0,0,1,1],PolyVal [1,0,1,0,0,1,0,1,1,0,1,1,0,0,1,0,1,0,1,1,1,0,1,1,1,1,0,1,1,1,1,1,1,1,1,0,0,1,0,0,0,0,1,1,1,1,1,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,1,1]],VectorVal [PolyVal [1,1,0,1,0,0,1,0,1,0,0,0,1,1,1,0,0,0,1,0,0,1,0,1,0,1,0,0,1,0,0,0,0,1,1,1,0,1,0,0,0,1,0,0,1,1,0,0,0,0,1,1,1,0,0,1,1,0,0,1,0,1,0,1],PolyVal [1,0,1,1,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,1,1,1,1,0,0,0,1,1,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,1,1,0,1,0,0,1,1,1,1,0,0,0,0,1,0,1,0,0]],VectorVal [PolyVal [0,1,0,1,1,0,1,0,0,0,1,1,1,0,0,1,0,1,1,0,1,1,0,0,1,0,0,1,0,1,0,0,1,0,0,1,0,1,0,0,1,1,1,1,0,1,0,0,0,1,0,1,1,0,1,1,0,1,1,0,0,1,1,1],PolyVal [0,1,0,0,1,0,0,1,1,1,0,0,0,0,1,1,0,1,1,1,1,1,0,0,0,1,1,1,0,1,0,0,0,0,1,0,0,0,1,1,0,1,1,0,0,0,0,0,1,1,1,0,0,0,1,0,1,0,0,0,0,1,0,1]],VectorVal [PolyVal [0,0,1,1,0,0,1,1,0,0,0,1,1,1,0,1,1,1,1,0,0,1,0,0,0,0,0,0,1,1,1,0,0,0,0,1,1,0,0,1,0,1,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,1,0,0,1,0,1],PolyVal [1,0,1,0,0,1,1,1,1,0,1,1,1,1,1,0,1,0,1,1,1,1,1,1,1,1,1,0,0,1,0,0,1,0,1,1,1,1,0,1,1,1,0,1,1,0,0,1,0,1,0,0,1,1,0,0,0,1,0,1,0,0,1,0]]]], start_saturated = False}";
      int reported = 0;
      arg2.val[0] = vcombine_p64(vcreate_p64(UINT64_C(0xc9325b20d9f95312)),
                                 vcreate_p64(UINT64_C(0xc5287c27fbdd4da5)));
      arg2.val[1] = vcombine_p64(vcreate_p64(UINT64_C(0xa99c322e12a4714b)),
                                 vcreate_p64(UINT64_C(0x2879684831f0249d)));
      arg2.val[2] = vcombine_p64(vcreate_p64(UINT64_C(0xe6da2f2929369c5a)),
                                 vcreate_p64(UINT64_C(0xa14706c42e3ec392)));
      arg2.val[3] = vcombine_p64(vcreate_p64(UINT64_C(0xa43402987027b8cc)),
                                 vcreate_p64(UINT64_C(0x4a329bbd27fd7de5)));
      clear_neon_saturated();
      vst4q_p64(result, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         poly64_t got;
         poly64_t exp;
         got = result[0];
         exp = -3948993726596426990;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu64 " Got: %" PRIu64 "\n",
                      "   Elem 0 ",
                      exp,
                      got);
            }
      }
      {
         poly64_t got;
         poly64_t exp;
         got = result[1];
         exp = -6225045411470216885;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu64 " Got: %" PRIu64 "\n",
                      "   Elem 1 ",
                      exp,
                      got);
            }
      }
      {
         poly64_t got;
         poly64_t exp;
         got = result[2];
         exp = -1812084046231593894;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu64 " Got: %" PRIu64 "\n",
                      "   Elem 2 ",
                      exp,
                      got);
            }
      }
      {
         poly64_t got;
         poly64_t exp;
         got = result[3];
         exp = -6614659098960480052;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu64 " Got: %" PRIu64 "\n",
                      "   Elem 3 ",
                      exp,
                      got);
            }
      }
      {
         poly64_t got;
         poly64_t exp;
         got = result[4];
         exp = -4240002537998168667;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu64 " Got: %" PRIu64 "\n",
                      "   Elem 4 ",
                      exp,
                      got);
            }
      }
      {
         poly64_t got;
         poly64_t exp;
         got = result[5];
         exp = 2916476892983862429;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu64 " Got: %" PRIu64 "\n",
                      "   Elem 5 ",
                      exp,
                      got);
            }
      }
      {
         poly64_t got;
         poly64_t exp;
         got = result[6];
         exp = -6825479270597475438;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu64 " Got: %" PRIu64 "\n",
                      "   Elem 6 ",
                      exp,
                      got);
            }
      }
      {
         poly64_t got;
         poly64_t exp;
         got = result[7];
         exp = 5346506944364248549;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu64 " Got: %" PRIu64 "\n",
                      "   Elem 7 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1644() {

{
   {
      uint8x8x4_t arg2;
      uint8_t result[32];
      char* str1 = "ReproInfo2 {semantics = \"store4\", fnname = \"vst4_u8\", rettype = \"__transfersize(32) uint8_t *\", argtypes = \"[/* result holder */,uint8x8x4_t]\", vals = [PtrVal [],ArrayVal [VectorVal [IntegerVal 128,IntegerVal 153,IntegerVal 128,IntegerVal 128,IntegerVal 128,IntegerVal 255,IntegerVal 128,IntegerVal 127],VectorVal [IntegerVal 127,IntegerVal 151,IntegerVal 255,IntegerVal 0,IntegerVal 33,IntegerVal 0,IntegerVal 214,IntegerVal 128],VectorVal [IntegerVal 118,IntegerVal 0,IntegerVal 255,IntegerVal 255,IntegerVal 128,IntegerVal 255,IntegerVal 10,IntegerVal 128],VectorVal [IntegerVal 255,IntegerVal 255,IntegerVal 255,IntegerVal 127,IntegerVal 127,IntegerVal 255,IntegerVal 127,IntegerVal 127]]], start_saturated = False}";
      int reported = 0;
      arg2.val[0] = vcreate_u8(UINT64_C(0x7f80ff8080809980));
      arg2.val[1] = vcreate_u8(UINT64_C(0x80d6002100ff977f));
      arg2.val[2] = vcreate_u8(UINT64_C(0x800aff80ffff0076));
      arg2.val[3] = vcreate_u8(UINT64_C(0x7f7fff7f7fffffff));
      clear_neon_saturated();
      vst4_u8(result, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint8_t got;
         uint8_t exp;
         got = result[0];
         exp = 128U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 0 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[1];
         exp = 127U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 1 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[2];
         exp = 118U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 2 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[3];
         exp = 255U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 3 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[4];
         exp = 153U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 4 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[5];
         exp = 151U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 5 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[6];
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 6 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[7];
         exp = 255U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 7 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[8];
         exp = 128U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 8 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[9];
         exp = 255U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 9 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[10];
         exp = 255U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 10 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[11];
         exp = 255U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 11 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[12];
         exp = 128U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 12 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[13];
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 13 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[14];
         exp = 255U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 14 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[15];
         exp = 127U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 15 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[16];
         exp = 128U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 16 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[17];
         exp = 33U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 17 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[18];
         exp = 128U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 18 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[19];
         exp = 127U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 19 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[20];
         exp = 255U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 20 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[21];
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 21 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[22];
         exp = 255U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 22 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[23];
         exp = 255U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 23 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[24];
         exp = 128U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 24 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[25];
         exp = 214U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 25 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[26];
         exp = 10U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 26 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[27];
         exp = 127U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 27 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[28];
         exp = 127U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 28 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[29];
         exp = 128U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 29 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[30];
         exp = 128U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 30 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[31];
         exp = 127U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 31 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1645() {

{
   {
      uint16x4x4_t arg2;
      uint16_t result[16];
      char* str1 = "ReproInfo2 {semantics = \"store4\", fnname = \"vst4_u16\", rettype = \"__transfersize(16) uint16_t *\", argtypes = \"[/* result holder */,uint16x4x4_t]\", vals = [PtrVal [],ArrayVal [VectorVal [IntegerVal 0,IntegerVal 45987,IntegerVal 65535,IntegerVal 12165],VectorVal [IntegerVal 32767,IntegerVal 65535,IntegerVal 51782,IntegerVal 65535],VectorVal [IntegerVal 32768,IntegerVal 32768,IntegerVal 0,IntegerVal 0],VectorVal [IntegerVal 32767,IntegerVal 8535,IntegerVal 32767,IntegerVal 65535]]], start_saturated = False}";
      int reported = 0;
      arg2.val[0] = vcreate_u16(UINT64_C(0x2f85ffffb3a30000));
      arg2.val[1] = vcreate_u16(UINT64_C(0xffffca46ffff7fff));
      arg2.val[2] = vcreate_u16(UINT64_C(0x0000000080008000));
      arg2.val[3] = vcreate_u16(UINT64_C(0xffff7fff21577fff));
      clear_neon_saturated();
      vst4_u16(result, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint16_t got;
         uint16_t exp;
         got = result[0];
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 0 ",
                      exp,
                      got);
            }
      }
      {
         uint16_t got;
         uint16_t exp;
         got = result[1];
         exp = 32767U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 1 ",
                      exp,
                      got);
            }
      }
      {
         uint16_t got;
         uint16_t exp;
         got = result[2];
         exp = 32768U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 2 ",
                      exp,
                      got);
            }
      }
      {
         uint16_t got;
         uint16_t exp;
         got = result[3];
         exp = 32767U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 3 ",
                      exp,
                      got);
            }
      }
      {
         uint16_t got;
         uint16_t exp;
         got = result[4];
         exp = 45987U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 4 ",
                      exp,
                      got);
            }
      }
      {
         uint16_t got;
         uint16_t exp;
         got = result[5];
         exp = 65535U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 5 ",
                      exp,
                      got);
            }
      }
      {
         uint16_t got;
         uint16_t exp;
         got = result[6];
         exp = 32768U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 6 ",
                      exp,
                      got);
            }
      }
      {
         uint16_t got;
         uint16_t exp;
         got = result[7];
         exp = 8535U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 7 ",
                      exp,
                      got);
            }
      }
      {
         uint16_t got;
         uint16_t exp;
         got = result[8];
         exp = 65535U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 8 ",
                      exp,
                      got);
            }
      }
      {
         uint16_t got;
         uint16_t exp;
         got = result[9];
         exp = 51782U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 9 ",
                      exp,
                      got);
            }
      }
      {
         uint16_t got;
         uint16_t exp;
         got = result[10];
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 10 ",
                      exp,
                      got);
            }
      }
      {
         uint16_t got;
         uint16_t exp;
         got = result[11];
         exp = 32767U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 11 ",
                      exp,
                      got);
            }
      }
      {
         uint16_t got;
         uint16_t exp;
         got = result[12];
         exp = 12165U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 12 ",
                      exp,
                      got);
            }
      }
      {
         uint16_t got;
         uint16_t exp;
         got = result[13];
         exp = 65535U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 13 ",
                      exp,
                      got);
            }
      }
      {
         uint16_t got;
         uint16_t exp;
         got = result[14];
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 14 ",
                      exp,
                      got);
            }
      }
      {
         uint16_t got;
         uint16_t exp;
         got = result[15];
         exp = 65535U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 15 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1646() {

{
   {
      uint32x2x4_t arg2;
      uint32_t result[8];
      char* str1 = "ReproInfo2 {semantics = \"store4\", fnname = \"vst4_u32\", rettype = \"__transfersize(8) uint32_t *\", argtypes = \"[/* result holder */,uint32x2x4_t]\", vals = [PtrVal [],ArrayVal [VectorVal [IntegerVal 0,IntegerVal 2147450879],VectorVal [IntegerVal 32767,IntegerVal 32768],VectorVal [IntegerVal 2147458493,IntegerVal 4294934528],VectorVal [IntegerVal 0,IntegerVal 2147483647]]], start_saturated = False}";
      int reported = 0;
      arg2.val[0] = vcreate_u32(UINT64_C(0x7fff7fff00000000));
      arg2.val[1] = vcreate_u32(UINT64_C(0x0000800000007fff));
      arg2.val[2] = vcreate_u32(UINT64_C(0xffff80007fff9dbd));
      arg2.val[3] = vcreate_u32(UINT64_C(0x7fffffff00000000));
      clear_neon_saturated();
      vst4_u32(result, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint32_t got;
         uint32_t exp;
         got = result[0];
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu32 " Got: %" PRIu32 "\n",
                      "   Elem 0 ",
                      exp,
                      got);
            }
      }
      {
         uint32_t got;
         uint32_t exp;
         got = result[1];
         exp = 32767U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu32 " Got: %" PRIu32 "\n",
                      "   Elem 1 ",
                      exp,
                      got);
            }
      }
      {
         uint32_t got;
         uint32_t exp;
         got = result[2];
         exp = 2147458493U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu32 " Got: %" PRIu32 "\n",
                      "   Elem 2 ",
                      exp,
                      got);
            }
      }
      {
         uint32_t got;
         uint32_t exp;
         got = result[3];
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu32 " Got: %" PRIu32 "\n",
                      "   Elem 3 ",
                      exp,
                      got);
            }
      }
      {
         uint32_t got;
         uint32_t exp;
         got = result[4];
         exp = 2147450879U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu32 " Got: %" PRIu32 "\n",
                      "   Elem 4 ",
                      exp,
                      got);
            }
      }
      {
         uint32_t got;
         uint32_t exp;
         got = result[5];
         exp = 32768U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu32 " Got: %" PRIu32 "\n",
                      "   Elem 5 ",
                      exp,
                      got);
            }
      }
      {
         uint32_t got;
         uint32_t exp;
         got = result[6];
         exp = 4294934528U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu32 " Got: %" PRIu32 "\n",
                      "   Elem 6 ",
                      exp,
                      got);
            }
      }
      {
         uint32_t got;
         uint32_t exp;
         got = result[7];
         exp = 2147483647U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu32 " Got: %" PRIu32 "\n",
                      "   Elem 7 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1647() {

{
   {
      uint64x1x4_t arg2;
      uint64_t result[4];
      char* str1 = "ReproInfo2 {semantics = \"store4\", fnname = \"vst4_u64\", rettype = \"__transfersize(4) uint64_t *\", argtypes = \"[/* result holder */,uint64x1x4_t]\", vals = [PtrVal [],ArrayVal [VectorVal [IntegerVal 240423679262720],VectorVal [IntegerVal 15103243558909181951],VectorVal [IntegerVal 9223090564145446911],VectorVal [IntegerVal 9223372034707226624]]], start_saturated = False}";
      int reported = 0;
      arg2.val[0] = vcreate_u64(UINT64_C(0x0000daa9ffff8000));
      arg2.val[1] = vcreate_u64(UINT64_C(0xd1997fff14fcffff));
      arg2.val[2] = vcreate_u64(UINT64_C(0x7fff000087257fff));
      arg2.val[3] = vcreate_u64(UINT64_C(0x7fffffff7fff0000));
      clear_neon_saturated();
      vst4_u64(result, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = result[0];
         exp = UINT64_C(0x0000daa9ffff8000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Elem 0 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = result[1];
         exp = UINT64_C(0xd1997fff14fcffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Elem 1 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = result[2];
         exp = UINT64_C(0x7fff000087257fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Elem 2 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = result[3];
         exp = UINT64_C(0x7fffffff7fff0000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Elem 3 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1648() {

{
   {
      int8x8x4_t arg2;
      int8_t result[32];
      char* str1 = "ReproInfo2 {semantics = \"store4\", fnname = \"vst4_s8\", rettype = \"__transfersize(32) int8_t *\", argtypes = \"[/* result holder */,int8x8x4_t]\", vals = [PtrVal [],ArrayVal [VectorVal [IntegerVal 6,IntegerVal 127,IntegerVal (-1),IntegerVal 0,IntegerVal 127,IntegerVal 102,IntegerVal (-1),IntegerVal 105],VectorVal [IntegerVal (-96),IntegerVal 0,IntegerVal 0,IntegerVal (-1),IntegerVal 127,IntegerVal 127,IntegerVal (-91),IntegerVal (-1)],VectorVal [IntegerVal 0,IntegerVal (-1),IntegerVal (-1),IntegerVal (-76),IntegerVal 17,IntegerVal 127,IntegerVal (-1),IntegerVal (-1)],VectorVal [IntegerVal 64,IntegerVal (-25),IntegerVal 0,IntegerVal 0,IntegerVal (-128),IntegerVal (-1),IntegerVal 0,IntegerVal (-128)]]], start_saturated = False}";
      int reported = 0;
      arg2.val[0] = vcreate_s8(UINT64_C(0x69ff667f00ff7f06));
      arg2.val[1] = vcreate_s8(UINT64_C(0xffa57f7fff0000a0));
      arg2.val[2] = vcreate_s8(UINT64_C(0xffff7f11b4ffff00));
      arg2.val[3] = vcreate_s8(UINT64_C(0x8000ff800000e740));
      clear_neon_saturated();
      vst4_s8(result, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         int8_t got;
         int8_t exp;
         got = result[0];
         exp = 6;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 0 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[1];
         exp = -96;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 1 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[2];
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 2 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[3];
         exp = 64;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 3 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[4];
         exp = 127;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 4 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[5];
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 5 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[6];
         exp = -1;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 6 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[7];
         exp = -25;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 7 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[8];
         exp = -1;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 8 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[9];
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 9 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[10];
         exp = -1;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 10 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[11];
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 11 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[12];
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 12 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[13];
         exp = -1;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 13 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[14];
         exp = -76;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 14 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[15];
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 15 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[16];
         exp = 127;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 16 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[17];
         exp = 127;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 17 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[18];
         exp = 17;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 18 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[19];
         exp = -128;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 19 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[20];
         exp = 102;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 20 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[21];
         exp = 127;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 21 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[22];
         exp = 127;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 22 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[23];
         exp = -1;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 23 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[24];
         exp = -1;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 24 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[25];
         exp = -91;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 25 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[26];
         exp = -1;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 26 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[27];
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 27 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[28];
         exp = 105;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 28 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[29];
         exp = -1;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 29 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[30];
         exp = -1;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 30 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[31];
         exp = -128;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 31 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1649() {

{
   {
      int16x4x4_t arg2;
      int16_t result[16];
      char* str1 = "ReproInfo2 {semantics = \"store4\", fnname = \"vst4_s16\", rettype = \"__transfersize(16) int16_t *\", argtypes = \"[/* result holder */,int16x4x4_t]\", vals = [PtrVal [],ArrayVal [VectorVal [IntegerVal 18132,IntegerVal (-1),IntegerVal (-8276),IntegerVal (-32768)],VectorVal [IntegerVal (-24615),IntegerVal 19987,IntegerVal (-32768),IntegerVal 11767],VectorVal [IntegerVal (-8545),IntegerVal 0,IntegerVal (-32768),IntegerVal (-32768)],VectorVal [IntegerVal 0,IntegerVal 3754,IntegerVal 23832,IntegerVal (-32768)]]], start_saturated = False}";
      int reported = 0;
      arg2.val[0] = vcreate_s16(UINT64_C(0x8000dfacffff46d4));
      arg2.val[1] = vcreate_s16(UINT64_C(0x2df780004e139fd9));
      arg2.val[2] = vcreate_s16(UINT64_C(0x800080000000de9f));
      arg2.val[3] = vcreate_s16(UINT64_C(0x80005d180eaa0000));
      clear_neon_saturated();
      vst4_s16(result, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         int16_t got;
         int16_t exp;
         got = result[0];
         exp = 18132;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi16 " Got: %" PRIi16 "\n",
                      "   Elem 0 ",
                      exp,
                      got);
            }
      }
      {
         int16_t got;
         int16_t exp;
         got = result[1];
         exp = -24615;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi16 " Got: %" PRIi16 "\n",
                      "   Elem 1 ",
                      exp,
                      got);
            }
      }
      {
         int16_t got;
         int16_t exp;
         got = result[2];
         exp = -8545;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi16 " Got: %" PRIi16 "\n",
                      "   Elem 2 ",
                      exp,
                      got);
            }
      }
      {
         int16_t got;
         int16_t exp;
         got = result[3];
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi16 " Got: %" PRIi16 "\n",
                      "   Elem 3 ",
                      exp,
                      got);
            }
      }
      {
         int16_t got;
         int16_t exp;
         got = result[4];
         exp = -1;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi16 " Got: %" PRIi16 "\n",
                      "   Elem 4 ",
                      exp,
                      got);
            }
      }
      {
         int16_t got;
         int16_t exp;
         got = result[5];
         exp = 19987;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi16 " Got: %" PRIi16 "\n",
                      "   Elem 5 ",
                      exp,
                      got);
            }
      }
      {
         int16_t got;
         int16_t exp;
         got = result[6];
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi16 " Got: %" PRIi16 "\n",
                      "   Elem 6 ",
                      exp,
                      got);
            }
      }
      {
         int16_t got;
         int16_t exp;
         got = result[7];
         exp = 3754;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi16 " Got: %" PRIi16 "\n",
                      "   Elem 7 ",
                      exp,
                      got);
            }
      }
      {
         int16_t got;
         int16_t exp;
         got = result[8];
         exp = -8276;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi16 " Got: %" PRIi16 "\n",
                      "   Elem 8 ",
                      exp,
                      got);
            }
      }
      {
         int16_t got;
         int16_t exp;
         got = result[9];
         exp = -32768;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi16 " Got: %" PRIi16 "\n",
                      "   Elem 9 ",
                      exp,
                      got);
            }
      }
      {
         int16_t got;
         int16_t exp;
         got = result[10];
         exp = -32768;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi16 " Got: %" PRIi16 "\n",
                      "   Elem 10 ",
                      exp,
                      got);
            }
      }
      {
         int16_t got;
         int16_t exp;
         got = result[11];
         exp = 23832;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi16 " Got: %" PRIi16 "\n",
                      "   Elem 11 ",
                      exp,
                      got);
            }
      }
      {
         int16_t got;
         int16_t exp;
         got = result[12];
         exp = -32768;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi16 " Got: %" PRIi16 "\n",
                      "   Elem 12 ",
                      exp,
                      got);
            }
      }
      {
         int16_t got;
         int16_t exp;
         got = result[13];
         exp = 11767;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi16 " Got: %" PRIi16 "\n",
                      "   Elem 13 ",
                      exp,
                      got);
            }
      }
      {
         int16_t got;
         int16_t exp;
         got = result[14];
         exp = -32768;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi16 " Got: %" PRIi16 "\n",
                      "   Elem 14 ",
                      exp,
                      got);
            }
      }
      {
         int16_t got;
         int16_t exp;
         got = result[15];
         exp = -32768;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi16 " Got: %" PRIi16 "\n",
                      "   Elem 15 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1650() {

{
   {
      int32x2x4_t arg2;
      int32_t result[8];
      char* str1 = "ReproInfo2 {semantics = \"store4\", fnname = \"vst4_s32\", rettype = \"__transfersize(8) int32_t *\", argtypes = \"[/* result holder */,int32x2x4_t]\", vals = [PtrVal [],ArrayVal [VectorVal [IntegerVal 32768,IntegerVal (-2147483648)],VectorVal [IntegerVal 2147450879,IntegerVal (-2147451826)],VectorVal [IntegerVal (-2147450881),IntegerVal (-1)],VectorVal [IntegerVal 2147450879,IntegerVal 1193115648]]], start_saturated = False}";
      int reported = 0;
      arg2.val[0] = vcreate_s32(UINT64_C(0x8000000000008000));
      arg2.val[1] = vcreate_s32(UINT64_C(0x80007c4e7fff7fff));
      arg2.val[2] = vcreate_s32(UINT64_C(0xffffffff80007fff));
      arg2.val[3] = vcreate_s32(UINT64_C(0x471d80007fff7fff));
      clear_neon_saturated();
      vst4_s32(result, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         int32_t got;
         int32_t exp;
         got = result[0];
         exp = 32768;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi32 " Got: %" PRIi32 "\n",
                      "   Elem 0 ",
                      exp,
                      got);
            }
      }
      {
         int32_t got;
         int32_t exp;
         got = result[1];
         exp = 2147450879;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi32 " Got: %" PRIi32 "\n",
                      "   Elem 1 ",
                      exp,
                      got);
            }
      }
      {
         int32_t got;
         int32_t exp;
         got = result[2];
         exp = -2147450881;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi32 " Got: %" PRIi32 "\n",
                      "   Elem 2 ",
                      exp,
                      got);
            }
      }
      {
         int32_t got;
         int32_t exp;
         got = result[3];
         exp = 2147450879;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi32 " Got: %" PRIi32 "\n",
                      "   Elem 3 ",
                      exp,
                      got);
            }
      }
      {
         int32_t got;
         int32_t exp;
         got = result[4];
         exp = (int32_t) 0x80000000;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi32 " Got: %" PRIi32 "\n",
                      "   Elem 4 ",
                      exp,
                      got);
            }
      }
      {
         int32_t got;
         int32_t exp;
         got = result[5];
         exp = -2147451826;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi32 " Got: %" PRIi32 "\n",
                      "   Elem 5 ",
                      exp,
                      got);
            }
      }
      {
         int32_t got;
         int32_t exp;
         got = result[6];
         exp = -1;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi32 " Got: %" PRIi32 "\n",
                      "   Elem 6 ",
                      exp,
                      got);
            }
      }
      {
         int32_t got;
         int32_t exp;
         got = result[7];
         exp = 1193115648;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi32 " Got: %" PRIi32 "\n",
                      "   Elem 7 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1651() {

{
   {
      int64x1x4_t arg2;
      int64_t result[4];
      char* str1 = "ReproInfo2 {semantics = \"store4\", fnname = \"vst4_s64\", rettype = \"__transfersize(4) int64_t *\", argtypes = \"[/* result holder */,int64x1x4_t]\", vals = [PtrVal [],ArrayVal [VectorVal [IntegerVal 4658270125873851941],VectorVal [IntegerVal 171001975406592],VectorVal [IntegerVal (-7589207277568)],VectorVal [IntegerVal 5425289438609503219]]], start_saturated = False}";
      int reported = 0;
      arg2.val[0] = vcreate_s64(UINT64_C(0x40a57fffb8866e25));
      arg2.val[1] = vcreate_s64(UINT64_C(0x00009b8680000000));
      arg2.val[2] = vcreate_s64(UINT64_C(0xfffff918ffff0000));
      arg2.val[3] = vcreate_s64(UINT64_C(0x4b4a7fffffff73f3));
      clear_neon_saturated();
      vst4_s64(result, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         int64_t got;
         int64_t exp;
         got = result[0];
         exp = INT64_C(4658270125873851941);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi64 " Got: %" PRIi64 "\n",
                      "   Elem 0 ",
                      exp,
                      got);
            }
      }
      {
         int64_t got;
         int64_t exp;
         got = result[1];
         exp = INT64_C(171001975406592);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi64 " Got: %" PRIi64 "\n",
                      "   Elem 1 ",
                      exp,
                      got);
            }
      }
      {
         int64_t got;
         int64_t exp;
         got = result[2];
         exp = INT64_C(-7589207277568);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi64 " Got: %" PRIi64 "\n",
                      "   Elem 2 ",
                      exp,
                      got);
            }
      }
      {
         int64_t got;
         int64_t exp;
         got = result[3];
         exp = INT64_C(5425289438609503219);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi64 " Got: %" PRIi64 "\n",
                      "   Elem 3 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1652() {

{
   {
      float32x2x4_t arg2;
      float32_t result[8];
      char* str1 = "ReproInfo2 {semantics = \"store4\", fnname = \"vst4_f32\", rettype = \"__transfersize(8) float32_t *\", argtypes = \"[/* result holder */,float32x2x4_t]\", vals = [PtrVal [],ArrayVal [VectorVal [FloatVal 0.3585197925567627,FloatVal 0.6394468545913696],VectorVal [FloatVal 0.8753487467765808,FloatVal 0.5948014259338379],VectorVal [FloatVal 0.8578997850418091,FloatVal 0.9136260747909546],VectorVal [FloatVal 0.7269151210784912,FloatVal 0.141434907913208]]], start_saturated = False}";
      int reported = 0;
      arg2.val[0] = vcreate_f32(UINT64_C(0x3f23b2ca3eb78fe8));
      arg2.val[1] = vcreate_f32(UINT64_C(0x3f1844e83f6016db));
      arg2.val[2] = vcreate_f32(UINT64_C(0x3f69e3663f5b9f52));
      arg2.val[3] = vcreate_f32(UINT64_C(0x3e10d4503f3a171c));
      clear_neon_saturated();
      vst4_f32(result, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = result[0];
         exp = ((float32_t) 0.3585197925567627);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 0 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = result[1];
         exp = ((float32_t) 0.8753487467765808);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 1 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = result[2];
         exp = ((float32_t) 0.8578997850418091);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 2 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = result[3];
         exp = ((float32_t) 0.7269151210784912);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 3 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = result[4];
         exp = ((float32_t) 0.6394468545913696);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 4 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = result[5];
         exp = ((float32_t) 0.5948014259338379);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 5 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = result[6];
         exp = ((float32_t) 0.9136260747909546);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 6 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = result[7];
         exp = ((float32_t) 0.141434907913208);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 7 ", exp, got);
            }
      }
   }
}
}
void dotests_1653() {

{
   {
      float64x1x4_t arg2;
      float64_t result[4];
      char* str1 = "ReproInfo2 {semantics = \"store4\", fnname = \"vst4_f64\", rettype = \"__transfersize(4) float64_t *\", argtypes = \"[/* result holder */,float64x1x4_t]\", vals = [PtrVal [],ArrayVal [VectorVal [FloatVal 0.5205400316603098],VectorVal [FloatVal 0.655689756507209],VectorVal [FloatVal 0.9846740191510058],VectorVal [FloatVal 0.7789436771534662]]], start_saturated = False}";
      int reported = 0;
      arg2.val[0] = vcreate_f64(UINT64_C(0x3fe0a8439187acbb));
      arg2.val[1] = vcreate_f64(UINT64_C(0x3fe4fb691590a94b));
      arg2.val[2] = vcreate_f64(UINT64_C(0x3fef827316af2ead));
      arg2.val[3] = vcreate_f64(UINT64_C(0x3fe8ed1b4a599a95));
      clear_neon_saturated();
      vst4_f64(result, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float64_t got;
         float64_t exp;
         got = result[0];
         exp = 0.5205400316603098;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 0 ", exp, got);
            }
      }
      {
         float64_t got;
         float64_t exp;
         got = result[1];
         exp = 0.655689756507209;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 1 ", exp, got);
            }
      }
      {
         float64_t got;
         float64_t exp;
         got = result[2];
         exp = 0.9846740191510058;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 2 ", exp, got);
            }
      }
      {
         float64_t got;
         float64_t exp;
         got = result[3];
         exp = 0.7789436771534662;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 3 ", exp, got);
            }
      }
   }
}
}
void dotests_1654() {

{
   {
      poly8x8x4_t arg2;
      poly8_t result[32];
      char* str1 = "ReproInfo2 {semantics = \"store4\", fnname = \"vst4_p8\", rettype = \"__transfersize(32) poly8_t *\", argtypes = \"[/* result holder */,poly8x8x4_t]\", vals = [PtrVal [],ArrayVal [VectorVal [PolyVal [1,0,1,0,1,1,1,0],PolyVal [0,0,0,1,1,0,0,0],PolyVal [0,0,0,1,0,1,0,0],PolyVal [1,0,1,0,1,1,1,1],PolyVal [0,1,1,1,1,0,1,0],PolyVal [0,0,0,0,1,1,0,1],PolyVal [0,0,1,0,0,1,0,0],PolyVal [1,1,0,1,1,1,1,1]],VectorVal [PolyVal [1,0,0,0,0,1,0,0],PolyVal [0,0,0,1,1,1,0,1],PolyVal [0,1,1,1,0,0,1,0],PolyVal [1,0,0,1,0,0,0,0],PolyVal [0,1,0,1,1,1,0,0],PolyVal [1,0,1,0,0,0,0,0],PolyVal [0,1,1,0,0,0,0,0],PolyVal [0,0,0,1,1,1,0,0]],VectorVal [PolyVal [1,0,0,1,0,1,0,0],PolyVal [1,0,0,1,1,0,0,1],PolyVal [1,1,0,1,1,0,0,0],PolyVal [1,1,0,1,1,0,0,1],PolyVal [0,1,0,0,1,1,0,1],PolyVal [1,0,0,1,1,0,0,1],PolyVal [1,0,0,1,1,0,1,0],PolyVal [1,0,1,1,1,0,1,0]],VectorVal [PolyVal [1,0,1,0,0,1,1,1],PolyVal [0,1,1,1,0,0,1,1],PolyVal [1,1,0,1,0,1,0,1],PolyVal [1,1,1,0,0,0,1,0],PolyVal [0,1,0,1,1,0,1,1],PolyVal [0,1,0,0,0,1,1,0],PolyVal [0,0,0,1,0,0,1,0],PolyVal [1,1,1,0,1,1,1,1]]]], start_saturated = False}";
      int reported = 0;
      arg2.val[0] = vcreate_p8(UINT64_C(0xfb24b05ef5281875));
      arg2.val[1] = vcreate_p8(UINT64_C(0x3806053a094eb821));
      arg2.val[2] = vcreate_p8(UINT64_C(0x5d5999b29b1b9929));
      arg2.val[3] = vcreate_p8(UINT64_C(0xf74862da47abcee5));
      clear_neon_saturated();
      vst4_p8(result, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         poly8_t got;
         poly8_t exp;
         got = result[0];
         exp = 117;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 0 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[1];
         exp = 33;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 1 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[2];
         exp = 41;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 2 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[3];
         exp = 229;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 3 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[4];
         exp = 24;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 4 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[5];
         exp = 184;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 5 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[6];
         exp = 153;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 6 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[7];
         exp = 206;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 7 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[8];
         exp = 40;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 8 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[9];
         exp = 78;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 9 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[10];
         exp = 27;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 10 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[11];
         exp = 171;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 11 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[12];
         exp = 245;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 12 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[13];
         exp = 9;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 13 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[14];
         exp = 155;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 14 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[15];
         exp = 71;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 15 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[16];
         exp = 94;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 16 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[17];
         exp = 58;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 17 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[18];
         exp = 178;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 18 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[19];
         exp = 218;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 19 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[20];
         exp = 176;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 20 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[21];
         exp = 5;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 21 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[22];
         exp = 153;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 22 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[23];
         exp = 98;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 23 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[24];
         exp = 36;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 24 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[25];
         exp = 6;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 25 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[26];
         exp = 89;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 26 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[27];
         exp = 72;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 27 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[28];
         exp = 251;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 28 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[29];
         exp = 56;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 29 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[30];
         exp = 93;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 30 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[31];
         exp = 247;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 31 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1655() {

{
   {
      poly16x4x4_t arg2;
      poly16_t result[16];
      char* str1 = "ReproInfo2 {semantics = \"store4\", fnname = \"vst4_p16\", rettype = \"__transfersize(16) poly16_t *\", argtypes = \"[/* result holder */,poly16x4x4_t]\", vals = [PtrVal [],ArrayVal [VectorVal [PolyVal [1,1,1,0,0,1,1,0,1,1,1,1,1,1,1,0],PolyVal [0,0,0,0,0,1,0,1,0,1,0,1,1,1,0,0],PolyVal [0,0,0,1,0,1,1,0,0,0,0,0,1,1,1,0],PolyVal [0,0,1,0,0,0,1,1,0,0,0,0,0,0,1,0]],VectorVal [PolyVal [0,1,1,0,1,0,1,0,0,0,0,0,1,0,1,0],PolyVal [1,0,0,0,0,0,1,0,0,1,1,0,0,1,1,1],PolyVal [1,0,0,0,0,0,0,0,1,1,0,0,1,0,0,1],PolyVal [1,1,0,0,0,0,0,1,0,1,1,0,0,1,0,0]],VectorVal [PolyVal [0,1,0,1,1,0,0,1,1,0,1,1,0,1,1,1],PolyVal [1,0,0,0,0,0,0,1,0,0,1,1,0,0,1,0],PolyVal [0,1,0,1,1,1,0,0,0,0,1,0,1,0,0,1],PolyVal [1,0,1,0,1,1,1,0,1,1,0,0,0,0,1,0]],VectorVal [PolyVal [0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0],PolyVal [1,0,1,0,0,1,1,0,1,1,1,1,0,0,0,0],PolyVal [1,1,1,0,1,1,1,0,0,1,1,0,1,0,1,1],PolyVal [0,1,0,1,1,1,0,1,0,1,1,0,0,0,1,1]]]], start_saturated = False}";
      int reported = 0;
      arg2.val[0] = vcreate_p16(UINT64_C(0x40c470683aa07f67));
      arg2.val[1] = vcreate_p16(UINT64_C(0x26839301e6415056));
      arg2.val[2] = vcreate_p16(UINT64_C(0x4375943a4c81ed9a));
      arg2.val[3] = vcreate_p16(UINT64_C(0xc6bad6770f653008));
      clear_neon_saturated();
      vst4_p16(result, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         poly16_t got;
         poly16_t exp;
         got = result[0];
         exp = 32615;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 0 ",
                      exp,
                      got);
            }
      }
      {
         poly16_t got;
         poly16_t exp;
         got = result[1];
         exp = 20566;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 1 ",
                      exp,
                      got);
            }
      }
      {
         poly16_t got;
         poly16_t exp;
         got = result[2];
         exp = 60826;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 2 ",
                      exp,
                      got);
            }
      }
      {
         poly16_t got;
         poly16_t exp;
         got = result[3];
         exp = 12296;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 3 ",
                      exp,
                      got);
            }
      }
      {
         poly16_t got;
         poly16_t exp;
         got = result[4];
         exp = 15008;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 4 ",
                      exp,
                      got);
            }
      }
      {
         poly16_t got;
         poly16_t exp;
         got = result[5];
         exp = 58945;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 5 ",
                      exp,
                      got);
            }
      }
      {
         poly16_t got;
         poly16_t exp;
         got = result[6];
         exp = 19585;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 6 ",
                      exp,
                      got);
            }
      }
      {
         poly16_t got;
         poly16_t exp;
         got = result[7];
         exp = 3941;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 7 ",
                      exp,
                      got);
            }
      }
      {
         poly16_t got;
         poly16_t exp;
         got = result[8];
         exp = 28776;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 8 ",
                      exp,
                      got);
            }
      }
      {
         poly16_t got;
         poly16_t exp;
         got = result[9];
         exp = 37633;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 9 ",
                      exp,
                      got);
            }
      }
      {
         poly16_t got;
         poly16_t exp;
         got = result[10];
         exp = 37946;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 10 ",
                      exp,
                      got);
            }
      }
      {
         poly16_t got;
         poly16_t exp;
         got = result[11];
         exp = 54903;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 11 ",
                      exp,
                      got);
            }
      }
      {
         poly16_t got;
         poly16_t exp;
         got = result[12];
         exp = 16580;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 12 ",
                      exp,
                      got);
            }
      }
      {
         poly16_t got;
         poly16_t exp;
         got = result[13];
         exp = 9859;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 13 ",
                      exp,
                      got);
            }
      }
      {
         poly16_t got;
         poly16_t exp;
         got = result[14];
         exp = 17269;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 14 ",
                      exp,
                      got);
            }
      }
      {
         poly16_t got;
         poly16_t exp;
         got = result[15];
         exp = 50874;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 15 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1656() {
#if __ARM_NEON_FP16_INTRINSICS

{
   {
      float16x4x4_t arg2;
      __fp16 result[16];
      char* str1 = "ReproInfo2 {semantics = \"store4\", fnname = \"vst4_f16\", rettype = \"__transfersize(16) __fp16 *\", argtypes = \"[/* result holder */,float16x4x4_t]\", vals = [PtrVal [],ArrayVal [VectorVal [FloatVal 4.310384208774705,FloatVal (-9.742630896488784),FloatVal (-8.10735701075609),FloatVal 3.6395695385542997],VectorVal [FloatVal 1.090223503033279,FloatVal (-1.1002343762541074),FloatVal 5.333240987274683,FloatVal 3.7622216163266238],VectorVal [FloatVal 2.017706776500958,FloatVal 0.12999774444498513,FloatVal 9.627445415315481,FloatVal 8.421905407442324],VectorVal [FloatVal 6.926654930101904,FloatVal 5.084985910453579,FloatVal 9.291187353595966,FloatVal 3.8997327353768814]]], start_saturated = False}";
      int reported = 0;
      arg2.val[0] = vcreate_f16(UINT64_C(0x4347c80dc8df444f));
      arg2.val[1] = vcreate_f16(UINT64_C(0x43864555bc663c5c));
      arg2.val[2] = vcreate_f16(UINT64_C(0x483648d030284009));
      arg2.val[3] = vcreate_f16(UINT64_C(0x43cc48a5451546ed));
      clear_neon_saturated();
      vst4_f16(result, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         __fp16 got;
         __fp16 exp;
         got = result[0];
         exp = 4.310384208774705;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 0 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = result[1];
         exp = 1.090223503033279;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 1 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = result[2];
         exp = 2.017706776500958;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 2 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = result[3];
         exp = 6.926654930101904;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 3 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = result[4];
         exp = -9.742630896488784;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 4 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = result[5];
         exp = -1.1002343762541074;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 5 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = result[6];
         exp = 0.12999774444498513;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 6 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = result[7];
         exp = 5.084985910453579;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 7 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = result[8];
         exp = -8.10735701075609;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 8 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = result[9];
         exp = 5.333240987274683;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 9 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = result[10];
         exp = 9.627445415315481;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 10 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = result[11];
         exp = 9.291187353595966;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 11 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = result[12];
         exp = 3.6395695385542997;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 12 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = result[13];
         exp = 3.7622216163266238;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 13 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = result[14];
         exp = 8.421905407442324;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 14 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = result[15];
         exp = 3.8997327353768814;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 15 ", exp, got);
            }
      }
   }
}
#endif
}
void dotests_1657() {

{
   {
      poly64x1x4_t arg2;
      poly64_t result[4];
      char* str1 = "ReproInfo2 {semantics = \"store4\", fnname = \"vst4_p64\", rettype = \"__transfersize(4) poly64_t *\", argtypes = \"[/* result holder */,poly64x1x4_t]\", vals = [PtrVal [],ArrayVal [VectorVal [PolyVal [0,1,0,1,0,1,1,0,1,1,1,1,1,1,1,1,0,0,0,1,1,0,0,0,1,1,1,1,1,1,0,1,0,1,0,0,1,1,1,1,0,1,1,0,1,0,1,1,1,0,1,1,1,0,1,0,0,1,1,0,1,1,0,0]],VectorVal [PolyVal [0,1,1,0,0,1,1,0,0,1,0,1,1,0,1,1,0,0,0,0,0,0,0,1,1,1,1,0,1,0,0,0,0,1,1,0,1,1,0,0,1,1,0,0,1,1,1,0,0,0,1,0,1,0,1,1,1,1,1,1,1,0,0,0]],VectorVal [PolyVal [0,1,1,0,1,0,0,1,0,0,0,1,1,1,0,1,1,0,1,0,1,0,1,0,0,0,1,1,1,0,0,0,0,1,0,1,1,0,1,1,1,0,1,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1,1,1,1,1,1,0]],VectorVal [PolyVal [1,1,0,1,0,1,1,0,1,1,0,0,0,1,0,1,1,0,0,0,1,1,0,0,0,0,1,1,0,1,0,1,0,0,1,1,1,0,0,1,0,0,1,1,0,1,0,1,1,0,1,1,0,1,0,1,0,0,0,0,0,1,1,1]]]], start_saturated = False}";
      int reported = 0;
      arg2.val[0] = vcreate_p64(UINT64_C(0x365dd6f2bf18ff6a));
      arg2.val[1] = vcreate_p64(UINT64_C(0x1fd473361780da66));
      arg2.val[2] = vcreate_p64(UINT64_C(0x7e2505da1c55b896));
      arg2.val[3] = vcreate_p64(UINT64_C(0xe0adac9cac31a36b));
      clear_neon_saturated();
      vst4_p64(result, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         poly64_t got;
         poly64_t exp;
         got = result[0];
         exp = 3917523588958715754;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu64 " Got: %" PRIu64 "\n",
                      "   Elem 0 ",
                      exp,
                      got);
            }
      }
      {
         poly64_t got;
         poly64_t exp;
         got = result[1];
         exp = 2293584786398173798;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu64 " Got: %" PRIu64 "\n",
                      "   Elem 1 ",
                      exp,
                      got);
            }
      }
      {
         poly64_t got;
         poly64_t exp;
         got = result[2];
         exp = 9089677857253603478;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu64 " Got: %" PRIu64 "\n",
                      "   Elem 2 ",
                      exp,
                      got);
            }
      }
      {
         poly64_t got;
         poly64_t exp;
         got = result[3];
         exp = -2256958049338940565;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu64 " Got: %" PRIu64 "\n",
                      "   Elem 3 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1658() {

{
   {
      uint8x16x2_t arg2;
      uint8_t result[2];
      char* str1 = "ReproInfo2 {semantics = \"store2_lane\", fnname = \"vst2q_lane_u8\", rettype = \"__transfersize(2) uint8_t *\", argtypes = \"[/* result holder */,uint8x16x2_t,__constrange(0,15) int]\", vals = [PtrVal [],ArrayVal [VectorVal [IntegerVal 255,IntegerVal 96,IntegerVal 255,IntegerVal 127,IntegerVal 128,IntegerVal 127,IntegerVal 0,IntegerVal 128,IntegerVal 127,IntegerVal 127,IntegerVal 255,IntegerVal 0,IntegerVal 127,IntegerVal 128,IntegerVal 159,IntegerVal 127],VectorVal [IntegerVal 255,IntegerVal 127,IntegerVal 128,IntegerVal 0,IntegerVal 128,IntegerVal 255,IntegerVal 0,IntegerVal 81,IntegerVal 255,IntegerVal 128,IntegerVal 216,IntegerVal 0,IntegerVal 241,IntegerVal 0,IntegerVal 0,IntegerVal 128]],IndexVal 13], start_saturated = False}";
      int reported = 0;
      arg2.val[0] = vcombine_u8(vcreate_u8(UINT64_C(0x80007f807fff60ff)),
                                vcreate_u8(UINT64_C(0x7f9f807f00ff7f7f)));
      arg2.val[1] = vcombine_u8(vcreate_u8(UINT64_C(0x5100ff8000807fff)),
                                vcreate_u8(UINT64_C(0x800000f100d880ff)));
      clear_neon_saturated();
      vst2q_lane_u8(result, arg2, 13);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint8_t got;
         uint8_t exp;
         got = result[0];
         exp = 128U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 0 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[1];
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 1 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1659() {

{
   {
      uint16x8x2_t arg2;
      uint16_t result[2];
      char* str1 = "ReproInfo2 {semantics = \"store2_lane\", fnname = \"vst2q_lane_u16\", rettype = \"__transfersize(2) uint16_t *\", argtypes = \"[/* result holder */,uint16x8x2_t,__constrange(0,7) int]\", vals = [PtrVal [],ArrayVal [VectorVal [IntegerVal 63768,IntegerVal 0,IntegerVal 32768,IntegerVal 32768,IntegerVal 32767,IntegerVal 65535,IntegerVal 32768,IntegerVal 32767],VectorVal [IntegerVal 32767,IntegerVal 44211,IntegerVal 32767,IntegerVal 0,IntegerVal 32767,IntegerVal 32768,IntegerVal 32767,IntegerVal 65535]],IndexVal 1], start_saturated = False}";
      int reported = 0;
      arg2.val[0] = vcombine_u16(vcreate_u16(UINT64_C(0x800080000000f918)),
                                 vcreate_u16(UINT64_C(0x7fff8000ffff7fff)));
      arg2.val[1] = vcombine_u16(vcreate_u16(UINT64_C(0x00007fffacb37fff)),
                                 vcreate_u16(UINT64_C(0xffff7fff80007fff)));
      clear_neon_saturated();
      vst2q_lane_u16(result, arg2, 1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint16_t got;
         uint16_t exp;
         got = result[0];
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 0 ",
                      exp,
                      got);
            }
      }
      {
         uint16_t got;
         uint16_t exp;
         got = result[1];
         exp = 44211U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 1 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1660() {

{
   {
      uint32x4x2_t arg2;
      uint32_t result[2];
      char* str1 = "ReproInfo2 {semantics = \"store2_lane\", fnname = \"vst2q_lane_u32\", rettype = \"__transfersize(2) uint32_t *\", argtypes = \"[/* result holder */,uint32x4x2_t,__constrange(0,3) int]\", vals = [PtrVal [],ArrayVal [VectorVal [IntegerVal 3410264063,IntegerVal 3831873626,IntegerVal 4294957343,IntegerVal 2147450880],VectorVal [IntegerVal 2147428832,IntegerVal 2147450879,IntegerVal 4294967295,IntegerVal 2147450879]],IndexVal 3], start_saturated = False}";
      int reported = 0;
      arg2.val[0] = vcombine_u32(vcreate_u32(UINT64_C(0xe465c05acb447fff)),
                                 vcreate_u32(UINT64_C(0x7fff8000ffffd91f)));
      arg2.val[1] = vcombine_u32(vcreate_u32(UINT64_C(0x7fff7fff7fff29e0)),
                                 vcreate_u32(UINT64_C(0x7fff7fffffffffff)));
      clear_neon_saturated();
      vst2q_lane_u32(result, arg2, 3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint32_t got;
         uint32_t exp;
         got = result[0];
         exp = 2147450880U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu32 " Got: %" PRIu32 "\n",
                      "   Elem 0 ",
                      exp,
                      got);
            }
      }
      {
         uint32_t got;
         uint32_t exp;
         got = result[1];
         exp = 2147450879U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu32 " Got: %" PRIu32 "\n",
                      "   Elem 1 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1661() {

{
   {
      int8x16x2_t arg2;
      int8_t result[2];
      char* str1 = "ReproInfo2 {semantics = \"store2_lane\", fnname = \"vst2q_lane_s8\", rettype = \"__transfersize(2) int8_t *\", argtypes = \"[/* result holder */,int8x16x2_t,__constrange(0,15) int]\", vals = [PtrVal [],ArrayVal [VectorVal [IntegerVal (-1),IntegerVal (-62),IntegerVal (-104),IntegerVal (-128),IntegerVal (-56),IntegerVal 127,IntegerVal 127,IntegerVal 127,IntegerVal (-1),IntegerVal (-1),IntegerVal (-128),IntegerVal (-128),IntegerVal (-1),IntegerVal (-1),IntegerVal (-1),IntegerVal 127],VectorVal [IntegerVal 28,IntegerVal 0,IntegerVal 127,IntegerVal (-128),IntegerVal 127,IntegerVal 127,IntegerVal 0,IntegerVal (-1),IntegerVal (-45),IntegerVal (-1),IntegerVal (-1),IntegerVal 0,IntegerVal (-5),IntegerVal (-1),IntegerVal (-1),IntegerVal 127]],IndexVal 3], start_saturated = False}";
      int reported = 0;
      arg2.val[0] = vcombine_s8(vcreate_s8(UINT64_C(0x7f7f7fc88098c2ff)),
                                vcreate_s8(UINT64_C(0x7fffffff8080ffff)));
      arg2.val[1] = vcombine_s8(vcreate_s8(UINT64_C(0xff007f7f807f001c)),
                                vcreate_s8(UINT64_C(0x7ffffffb00ffffd3)));
      clear_neon_saturated();
      vst2q_lane_s8(result, arg2, 3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         int8_t got;
         int8_t exp;
         got = result[0];
         exp = -128;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 0 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[1];
         exp = -128;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 1 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1662() {

{
   {
      int16x8x2_t arg2;
      int16_t result[2];
      char* str1 = "ReproInfo2 {semantics = \"store2_lane\", fnname = \"vst2q_lane_s16\", rettype = \"__transfersize(2) int16_t *\", argtypes = \"[/* result holder */,int16x8x2_t,__constrange(0,7) int]\", vals = [PtrVal [],ArrayVal [VectorVal [IntegerVal 0,IntegerVal (-1),IntegerVal (-32768),IntegerVal 0,IntegerVal 32767,IntegerVal 32767,IntegerVal 32767,IntegerVal (-32768)],VectorVal [IntegerVal 0,IntegerVal (-32768),IntegerVal 32767,IntegerVal 32767,IntegerVal (-1),IntegerVal 0,IntegerVal 32767,IntegerVal (-1)]],IndexVal 5], start_saturated = False}";
      int reported = 0;
      arg2.val[0] = vcombine_s16(vcreate_s16(UINT64_C(0x00008000ffff0000)),
                                 vcreate_s16(UINT64_C(0x80007fff7fff7fff)));
      arg2.val[1] = vcombine_s16(vcreate_s16(UINT64_C(0x7fff7fff80000000)),
                                 vcreate_s16(UINT64_C(0xffff7fff0000ffff)));
      clear_neon_saturated();
      vst2q_lane_s16(result, arg2, 5);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         int16_t got;
         int16_t exp;
         got = result[0];
         exp = 32767;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi16 " Got: %" PRIi16 "\n",
                      "   Elem 0 ",
                      exp,
                      got);
            }
      }
      {
         int16_t got;
         int16_t exp;
         got = result[1];
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi16 " Got: %" PRIi16 "\n",
                      "   Elem 1 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1663() {

{
   {
      int32x4x2_t arg2;
      int32_t result[2];
      char* str1 = "ReproInfo2 {semantics = \"store2_lane\", fnname = \"vst2q_lane_s32\", rettype = \"__transfersize(2) int32_t *\", argtypes = \"[/* result holder */,int32x4x2_t,__constrange(0,3) int]\", vals = [PtrVal [],ArrayVal [VectorVal [IntegerVal 2147450879,IntegerVal (-2147450881),IntegerVal (-2147450880),IntegerVal (-32769)],VectorVal [IntegerVal (-2147450880),IntegerVal 2147418112,IntegerVal 32768,IntegerVal (-2147479984)]],IndexVal 2], start_saturated = False}";
      int reported = 0;
      arg2.val[0] = vcombine_s32(vcreate_s32(UINT64_C(0x80007fff7fff7fff)),
                                 vcreate_s32(UINT64_C(0xffff7fff80008000)));
      arg2.val[1] = vcombine_s32(vcreate_s32(UINT64_C(0x7fff000080008000)),
                                 vcreate_s32(UINT64_C(0x80000e5000008000)));
      clear_neon_saturated();
      vst2q_lane_s32(result, arg2, 2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         int32_t got;
         int32_t exp;
         got = result[0];
         exp = -2147450880;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi32 " Got: %" PRIi32 "\n",
                      "   Elem 0 ",
                      exp,
                      got);
            }
      }
      {
         int32_t got;
         int32_t exp;
         got = result[1];
         exp = 32768;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi32 " Got: %" PRIi32 "\n",
                      "   Elem 1 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1664() {

{
   {
      float32x4x2_t arg2;
      float32_t result[2];
      char* str1 = "ReproInfo2 {semantics = \"store2_lane\", fnname = \"vst2q_lane_f32\", rettype = \"__transfersize(2) float32_t *\", argtypes = \"[/* result holder */,float32x4x2_t,__constrange(0,3) int]\", vals = [PtrVal [],ArrayVal [VectorVal [FloatVal 0.20402055978775024,FloatVal 0.46642106771469116,FloatVal 0.10780203342437744,FloatVal 0.7367430925369263],VectorVal [FloatVal 5.871063470840454e-2,FloatVal 0.21515953540802002,FloatVal 0.32406604290008545,FloatVal 0.704336941242218]],IndexVal 1], start_saturated = True}";
      int reported = 0;
      arg2.val[0] = vcombine_f32(vcreate_f32(UINT64_C(0x3eeecebe3e50eac4)),
                                 vcreate_f32(UINT64_C(0x3f3c9b323ddcc750)));
      arg2.val[1] = vcombine_f32(vcreate_f32(UINT64_C(0x3e5c52c83d707a90)),
                                 vcreate_f32(UINT64_C(0x3f344f6d3ea5ebfc)));
      set_neon_saturated();
      vst2q_lane_f32(result, arg2, 1);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = result[0];
         exp = ((float32_t) 0.46642106771469116);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 0 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = result[1];
         exp = ((float32_t) 0.21515953540802002);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 1 ", exp, got);
            }
      }
   }
}
}
void dotests_1665() {

{
   {
      float64x2x2_t arg2;
      float64_t result[2];
      char* str1 = "ReproInfo2 {semantics = \"store2_lane\", fnname = \"vst2q_lane_f64\", rettype = \"__transfersize(2) float64_t *\", argtypes = \"[/* result holder */,float64x2x2_t,__constrange(0,1) int]\", vals = [PtrVal [],ArrayVal [VectorVal [FloatVal 0.8069902575776529,FloatVal 0.1042335547943688],VectorVal [FloatVal 0.359648793132227,FloatVal 0.14863567865172456]],IndexVal 1], start_saturated = False}";
      int reported = 0;
      arg2.val[0] = vcombine_f64(vcreate_f64(UINT64_C(0x3fe9d2dd3b8f9284)),
                                 vcreate_f64(UINT64_C(0x3fbaaf0cdcfcd5d8)));
      arg2.val[1] = vcombine_f64(vcreate_f64(UINT64_C(0x3fd7047c5f231f48)),
                                 vcreate_f64(UINT64_C(0x3fc3067e7169f95c)));
      clear_neon_saturated();
      vst2q_lane_f64(result, arg2, 1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float64_t got;
         float64_t exp;
         got = result[0];
         exp = 0.1042335547943688;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 0 ", exp, got);
            }
      }
      {
         float64_t got;
         float64_t exp;
         got = result[1];
         exp = 0.14863567865172456;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 1 ", exp, got);
            }
      }
   }
}
}
void dotests_1666() {

{
   {
      poly8x16x2_t arg2;
      poly8_t result[2];
      char* str1 = "ReproInfo2 {semantics = \"store2_lane\", fnname = \"vst2q_lane_p8\", rettype = \"__transfersize(2) poly8_t *\", argtypes = \"[/* result holder */,poly8x16x2_t,__constrange(0,15) int]\", vals = [PtrVal [],ArrayVal [VectorVal [PolyVal [0,1,1,1,0,0,0,0],PolyVal [0,0,1,0,0,1,1,1],PolyVal [1,1,0,0,0,0,0,0],PolyVal [0,0,0,0,1,1,1,0],PolyVal [1,0,1,0,1,0,1,0],PolyVal [0,0,0,1,0,1,1,1],PolyVal [1,0,0,0,1,0,1,0],PolyVal [1,1,1,1,1,1,0,1],PolyVal [1,1,1,1,1,1,1,1],PolyVal [0,1,1,0,1,1,1,1],PolyVal [1,1,1,0,1,1,1,1],PolyVal [0,1,1,1,1,0,1,0],PolyVal [0,0,1,1,0,1,0,0],PolyVal [1,1,1,1,1,0,0,1],PolyVal [0,0,1,0,0,0,1,1],PolyVal [1,1,0,0,0,1,1,1]],VectorVal [PolyVal [0,0,1,1,1,0,1,0],PolyVal [0,1,0,1,1,1,0,1],PolyVal [1,1,1,0,0,0,1,0],PolyVal [0,1,1,1,0,1,1,1],PolyVal [1,1,0,1,1,1,0,0],PolyVal [1,1,0,0,1,0,1,0],PolyVal [0,0,1,1,0,1,1,1],PolyVal [1,0,0,0,1,0,0,0],PolyVal [1,1,0,0,0,0,0,0],PolyVal [0,0,1,1,0,1,1,1],PolyVal [0,0,1,1,1,1,1,1],PolyVal [1,1,0,0,0,1,1,1],PolyVal [0,0,0,1,0,0,0,1],PolyVal [1,0,1,1,0,0,1,0],PolyVal [0,0,1,1,1,0,0,1],PolyVal [1,0,1,0,0,1,1,0]]],IndexVal 4], start_saturated = False}";
      int reported = 0;
      arg2.val[0] = vcombine_p8(vcreate_p8(UINT64_C(0xbf51e8557003e40e)),
                                vcreate_p8(UINT64_C(0xe3c49f2c5ef7f6ff)));
      arg2.val[1] = vcombine_p8(vcreate_p8(UINT64_C(0x11ec533bee47ba5c)),
                                vcreate_p8(UINT64_C(0x659c4d88e3fcec03)));
      clear_neon_saturated();
      vst2q_lane_p8(result, arg2, 4);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         poly8_t got;
         poly8_t exp;
         got = result[0];
         exp = 85;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 0 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[1];
         exp = 59;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 1 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1667() {

{
   {
      poly16x8x2_t arg2;
      poly16_t result[2];
      char* str1 = "ReproInfo2 {semantics = \"store2_lane\", fnname = \"vst2q_lane_p16\", rettype = \"__transfersize(2) poly16_t *\", argtypes = \"[/* result holder */,poly16x8x2_t,__constrange(0,7) int]\", vals = [PtrVal [],ArrayVal [VectorVal [PolyVal [0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,1],PolyVal [1,0,1,1,0,1,1,1,0,0,1,1,0,0,0,0],PolyVal [0,1,1,0,1,0,0,1,1,0,1,1,0,0,1,1],PolyVal [0,1,0,1,0,0,1,0,1,0,0,0,1,1,0,1],PolyVal [1,0,1,1,0,0,0,0,0,1,1,0,1,0,0,0],PolyVal [1,0,1,0,0,1,1,0,1,1,0,0,1,1,0,0],PolyVal [1,1,0,0,0,1,0,0,0,0,0,0,1,0,1,0],PolyVal [0,1,1,0,1,1,0,1,1,0,1,0,0,0,1,1]],VectorVal [PolyVal [0,0,1,1,1,0,0,1,0,1,0,1,0,0,0,0],PolyVal [1,0,1,1,1,0,0,0,1,0,1,0,1,0,0,0],PolyVal [1,1,1,0,1,1,1,1,0,0,1,0,1,0,0,0],PolyVal [0,0,0,1,0,0,0,0,1,1,0,1,0,0,1,0],PolyVal [1,1,1,0,1,0,1,1,0,0,1,0,0,0,1,1],PolyVal [0,0,0,0,0,0,0,0,0,0,1,1,0,1,1,1],PolyVal [1,1,0,1,0,1,1,0,1,1,0,0,1,1,1,1],PolyVal [0,0,1,1,0,0,1,1,0,1,1,1,1,0,0,0]]],IndexVal 2], start_saturated = False}";
      int reported = 0;
      arg2.val[0] = vcombine_p16(vcreate_p16(UINT64_C(0xb14acd960ced8602)),
                                 vcreate_p16(UINT64_C(0xc5b650233365160d)));
      arg2.val[1] = vcombine_p16(vcreate_p16(UINT64_C(0x4b0814f7151d0a9c)),
                                 vcreate_p16(UINT64_C(0x1eccf36bec00c4d7)));
      clear_neon_saturated();
      vst2q_lane_p16(result, arg2, 2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         poly16_t got;
         poly16_t exp;
         got = result[0];
         exp = 52630;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 0 ",
                      exp,
                      got);
            }
      }
      {
         poly16_t got;
         poly16_t exp;
         got = result[1];
         exp = 5367;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 1 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1668() {
#if __ARM_NEON_FP16_INTRINSICS

{
   {
      float16x8x2_t arg2;
      __fp16 result[2];
      char* str1 = "ReproInfo2 {semantics = \"store2_lane\", fnname = \"vst2q_lane_f16\", rettype = \"__transfersize(2) __fp16 *\", argtypes = \"[/* result holder */,float16x8x2_t,__constrange(0,7) int]\", vals = [PtrVal [],ArrayVal [VectorVal [FloatVal 4.538648292767322,FloatVal (-7.765021076007546),FloatVal (-3.7494994866623355),FloatVal 2.052255490660082,FloatVal (-8.234367804544355),FloatVal 1.147187431261571,FloatVal 2.1513311585047,FloatVal 0.30317920119696495],VectorVal [FloatVal (-5.761431941022237),FloatVal 3.074554524382769,FloatVal (-8.634325006626476),FloatVal (-1.405369371846085),FloatVal 1.3698323843950906,FloatVal (-3.720865119929206),FloatVal 4.245688569807077,FloatVal (-0.5875169169204053)]],IndexVal 5], start_saturated = False}";
      int reported = 0;
      arg2.val[0] = vcombine_f16(vcreate_f16(UINT64_C(0x401ac37fc7c34489)),
                                 vcreate_f16(UINT64_C(0x34d9404d3c96c81d)));
      arg2.val[1] = vcombine_f16(vcreate_f16(UINT64_C(0xbd9fc8514226c5c2)),
                                 vcreate_f16(UINT64_C(0xb8b3443ec3713d7a)));
      clear_neon_saturated();
      vst2q_lane_f16(result, arg2, 5);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         __fp16 got;
         __fp16 exp;
         got = result[0];
         exp = 1.147187431261571;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 0 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = result[1];
         exp = -3.720865119929206;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 1 ", exp, got);
            }
      }
   }
}
#endif
}
void dotests_1669() {

{
   {
      uint64x2x2_t arg2;
      uint64_t result[2];
      char* str1 = "ReproInfo2 {semantics = \"store2_lane\", fnname = \"vst2q_lane_u64\", rettype = \"__transfersize(2) uint64_t *\", argtypes = \"[/* result holder */,uint64x2x2_t,__constrange(0,1) int]\", vals = [PtrVal [],ArrayVal [VectorVal [IntegerVal 9223512772867096576,IntegerVal 6379911819976212479],VectorVal [IntegerVal 140739635806207,IntegerVal 9223090564025561504]],IndexVal 0], start_saturated = False}";
      int reported = 0;
      arg2.val[0] = vcombine_u64(vcreate_u64(UINT64_C(0x80007fffa8058000)),
                                 vcreate_u64(UINT64_C(0x5889ffff7fff7fff)));
      arg2.val[1] = vcombine_u64(vcreate_u64(UINT64_C(0x000080007fff7fff)),
                                 vcreate_u64(UINT64_C(0x7fff0000800031a0)));
      clear_neon_saturated();
      vst2q_lane_u64(result, arg2, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = result[0];
         exp = UINT64_C(0x80007fffa8058000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Elem 0 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = result[1];
         exp = UINT64_C(0x000080007fff7fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Elem 1 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1670() {

{
   {
      int64x2x2_t arg2;
      int64_t result[2];
      char* str1 = "ReproInfo2 {semantics = \"store2_lane\", fnname = \"vst2q_lane_s64\", rettype = \"__transfersize(2) int64_t *\", argtypes = \"[/* result holder */,int64x2x2_t,__constrange(0,1) int]\", vals = [PtrVal [],ArrayVal [VectorVal [IntegerVal (-9223090564025614336),IntegerVal (-4044168427079270401)],VectorVal [IntegerVal 3057735289167352781,IntegerVal 259830489055232]],IndexVal 1], start_saturated = False}";
      int reported = 0;
      arg2.val[0] = vcombine_s64(vcreate_s64(UINT64_C(0x8000ffff7fff0000)),
                                 vcreate_s64(UINT64_C(0xc7e03a3e1416ffff)));
      arg2.val[1] = vcombine_s64(vcreate_s64(UINT64_C(0x2a6f420b7fff13cd)),
                                 vcreate_s64(UINT64_C(0x0000ec5080008000)));
      clear_neon_saturated();
      vst2q_lane_s64(result, arg2, 1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         int64_t got;
         int64_t exp;
         got = result[0];
         exp = INT64_C(-4044168427079270401);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi64 " Got: %" PRIi64 "\n",
                      "   Elem 0 ",
                      exp,
                      got);
            }
      }
      {
         int64_t got;
         int64_t exp;
         got = result[1];
         exp = INT64_C(259830489055232);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi64 " Got: %" PRIi64 "\n",
                      "   Elem 1 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1671() {

{
   {
      poly64x2x2_t arg2;
      poly64_t result[2];
      char* str1 = "ReproInfo2 {semantics = \"store2_lane\", fnname = \"vst2q_lane_p64\", rettype = \"__transfersize(2) poly64_t *\", argtypes = \"[/* result holder */,poly64x2x2_t,__constrange(0,1) int]\", vals = [PtrVal [],ArrayVal [VectorVal [PolyVal [1,1,1,1,1,1,0,1,0,1,0,1,0,0,0,1,1,0,0,0,1,1,0,1,1,1,0,0,1,0,0,0,0,0,1,0,0,1,1,0,1,1,0,1,1,0,0,1,0,1,0,1,1,1,1,1,1,0,0,0,0,1,0,1],PolyVal [0,1,1,0,1,1,1,0,0,1,0,1,1,0,1,1,1,1,1,1,0,0,1,0,1,1,0,0,0,1,0,1,1,1,1,0,1,0,0,1,0,1,1,1,1,0,0,0,1,1,0,1,0,1,1,0,1,1,1,1,1,0,0,1]],VectorVal [PolyVal [1,0,0,1,0,0,1,0,0,1,1,1,0,0,1,1,0,0,1,0,1,1,1,0,1,0,0,0,1,0,0,1,1,1,1,0,1,0,1,1,1,1,0,0,0,0,0,1,0,1,0,1,0,0,0,1,1,1,0,0,0,1,1,1],PolyVal [1,1,1,0,1,0,1,1,1,1,1,0,1,0,0,0,0,1,0,0,0,1,1,0,0,0,0,1,0,1,1,1,0,1,0,1,1,1,1,0,1,1,0,1,1,0,0,1,1,1,1,0,0,0,1,0,1,0,1,1,0,0,1,0]]],IndexVal 0], start_saturated = False}";
      int reported = 0;
      arg2.val[0] = vcombine_p64(vcreate_p64(UINT64_C(0xa1fa9b6413b18abf)),
                                 vcreate_p64(UINT64_C(0x9f6b1e97a34fda76)));
      arg2.val[1] = vcombine_p64(vcreate_p64(UINT64_C(0xe38a83d79174ce49)),
                                 vcreate_p64(UINT64_C(0x4d479b7ae86217d7)));
      clear_neon_saturated();
      vst2q_lane_p64(result, arg2, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         poly64_t got;
         poly64_t exp;
         got = result[0];
         exp = -6774931835296052545;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu64 " Got: %" PRIu64 "\n",
                      "   Elem 0 ",
                      exp,
                      got);
            }
      }
      {
         poly64_t got;
         poly64_t exp;
         got = result[1];
         exp = -2050681718432281015;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu64 " Got: %" PRIu64 "\n",
                      "   Elem 1 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1672() {

{
   {
      uint8x8x2_t arg2;
      uint8_t result[2];
      char* str1 = "ReproInfo2 {semantics = \"store2_lane\", fnname = \"vst2_lane_u8\", rettype = \"__transfersize(2) uint8_t *\", argtypes = \"[/* result holder */,uint8x8x2_t,__constrange(0,7) int]\", vals = [PtrVal [],ArrayVal [VectorVal [IntegerVal 255,IntegerVal 255,IntegerVal 255,IntegerVal 255,IntegerVal 25,IntegerVal 0,IntegerVal 115,IntegerVal 127],VectorVal [IntegerVal 255,IntegerVal 255,IntegerVal 178,IntegerVal 142,IntegerVal 127,IntegerVal 127,IntegerVal 128,IntegerVal 0]],IndexVal 3], start_saturated = False}";
      int reported = 0;
      arg2.val[0] = vcreate_u8(UINT64_C(0x7f730019ffffffff));
      arg2.val[1] = vcreate_u8(UINT64_C(0x00807f7f8eb2ffff));
      clear_neon_saturated();
      vst2_lane_u8(result, arg2, 3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint8_t got;
         uint8_t exp;
         got = result[0];
         exp = 255U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 0 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[1];
         exp = 142U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 1 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1673() {

{
   {
      uint16x4x2_t arg2;
      uint16_t result[2];
      char* str1 = "ReproInfo2 {semantics = \"store2_lane\", fnname = \"vst2_lane_u16\", rettype = \"__transfersize(2) uint16_t *\", argtypes = \"[/* result holder */,uint16x4x2_t,__constrange(0,3) int]\", vals = [PtrVal [],ArrayVal [VectorVal [IntegerVal 65535,IntegerVal 32767,IntegerVal 26483,IntegerVal 32767],VectorVal [IntegerVal 32768,IntegerVal 32768,IntegerVal 65535,IntegerVal 65535]],IndexVal 3], start_saturated = False}";
      int reported = 0;
      arg2.val[0] = vcreate_u16(UINT64_C(0x7fff67737fffffff));
      arg2.val[1] = vcreate_u16(UINT64_C(0xffffffff80008000));
      clear_neon_saturated();
      vst2_lane_u16(result, arg2, 3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint16_t got;
         uint16_t exp;
         got = result[0];
         exp = 32767U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 0 ",
                      exp,
                      got);
            }
      }
      {
         uint16_t got;
         uint16_t exp;
         got = result[1];
         exp = 65535U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 1 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1674() {

{
   {
      uint32x2x2_t arg2;
      uint32_t result[2];
      char* str1 = "ReproInfo2 {semantics = \"store2_lane\", fnname = \"vst2_lane_u32\", rettype = \"__transfersize(2) uint32_t *\", argtypes = \"[/* result holder */,uint32x2x2_t,__constrange(0,1) int]\", vals = [PtrVal [],ArrayVal [VectorVal [IntegerVal 2147418765,IntegerVal 4294934527],VectorVal [IntegerVal 4294922609,IntegerVal 54283]],IndexVal 0], start_saturated = False}";
      int reported = 0;
      arg2.val[0] = vcreate_u32(UINT64_C(0xffff7fff7fff028d));
      arg2.val[1] = vcreate_u32(UINT64_C(0x0000d40bffff5171));
      clear_neon_saturated();
      vst2_lane_u32(result, arg2, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint32_t got;
         uint32_t exp;
         got = result[0];
         exp = 2147418765U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu32 " Got: %" PRIu32 "\n",
                      "   Elem 0 ",
                      exp,
                      got);
            }
      }
      {
         uint32_t got;
         uint32_t exp;
         got = result[1];
         exp = 4294922609U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu32 " Got: %" PRIu32 "\n",
                      "   Elem 1 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1675() {

{
   {
      int8x8x2_t arg2;
      int8_t result[2];
      char* str1 = "ReproInfo2 {semantics = \"store2_lane\", fnname = \"vst2_lane_s8\", rettype = \"__transfersize(2) int8_t *\", argtypes = \"[/* result holder */,int8x8x2_t,__constrange(0,7) int]\", vals = [PtrVal [],ArrayVal [VectorVal [IntegerVal (-128),IntegerVal (-57),IntegerVal (-1),IntegerVal 127,IntegerVal (-1),IntegerVal (-128),IntegerVal 127,IntegerVal (-1)],VectorVal [IntegerVal (-1),IntegerVal (-1),IntegerVal (-4),IntegerVal 127,IntegerVal (-128),IntegerVal (-128),IntegerVal (-1),IntegerVal 6]],IndexVal 7], start_saturated = False}";
      int reported = 0;
      arg2.val[0] = vcreate_s8(UINT64_C(0xff7f80ff7fffc780));
      arg2.val[1] = vcreate_s8(UINT64_C(0x06ff80807ffcffff));
      clear_neon_saturated();
      vst2_lane_s8(result, arg2, 7);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         int8_t got;
         int8_t exp;
         got = result[0];
         exp = -1;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 0 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[1];
         exp = 6;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 1 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1676() {

{
   {
      int16x4x2_t arg2;
      int16_t result[2];
      char* str1 = "ReproInfo2 {semantics = \"store2_lane\", fnname = \"vst2_lane_s16\", rettype = \"__transfersize(2) int16_t *\", argtypes = \"[/* result holder */,int16x4x2_t,__constrange(0,3) int]\", vals = [PtrVal [],ArrayVal [VectorVal [IntegerVal (-1),IntegerVal 0,IntegerVal (-27834),IntegerVal (-32768)],VectorVal [IntegerVal (-20881),IntegerVal (-1),IntegerVal 32767,IntegerVal (-32768)]],IndexVal 2], start_saturated = False}";
      int reported = 0;
      arg2.val[0] = vcreate_s16(UINT64_C(0x800093460000ffff));
      arg2.val[1] = vcreate_s16(UINT64_C(0x80007fffffffae6f));
      clear_neon_saturated();
      vst2_lane_s16(result, arg2, 2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         int16_t got;
         int16_t exp;
         got = result[0];
         exp = -27834;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi16 " Got: %" PRIi16 "\n",
                      "   Elem 0 ",
                      exp,
                      got);
            }
      }
      {
         int16_t got;
         int16_t exp;
         got = result[1];
         exp = 32767;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi16 " Got: %" PRIi16 "\n",
                      "   Elem 1 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1677() {

{
   {
      int32x2x2_t arg2;
      int32_t result[2];
      char* str1 = "ReproInfo2 {semantics = \"store2_lane\", fnname = \"vst2_lane_s32\", rettype = \"__transfersize(2) int32_t *\", argtypes = \"[/* result holder */,int32x2x2_t,__constrange(0,1) int]\", vals = [PtrVal [],ArrayVal [VectorVal [IntegerVal 14861,IntegerVal 2147450879],VectorVal [IntegerVal (-2147439991),IntegerVal (-1)]],IndexVal 0], start_saturated = False}";
      int reported = 0;
      arg2.val[0] = vcreate_s32(UINT64_C(0x7fff7fff00003a0d));
      arg2.val[1] = vcreate_s32(UINT64_C(0xffffffff8000aa89));
      clear_neon_saturated();
      vst2_lane_s32(result, arg2, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         int32_t got;
         int32_t exp;
         got = result[0];
         exp = 14861;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi32 " Got: %" PRIi32 "\n",
                      "   Elem 0 ",
                      exp,
                      got);
            }
      }
      {
         int32_t got;
         int32_t exp;
         got = result[1];
         exp = -2147439991;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi32 " Got: %" PRIi32 "\n",
                      "   Elem 1 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1678() {

{
   {
      float32x2x2_t arg2;
      float32_t result[2];
      char* str1 = "ReproInfo2 {semantics = \"store2_lane\", fnname = \"vst2_lane_f32\", rettype = \"__transfersize(2) float32_t *\", argtypes = \"[/* result holder */,float32x2x2_t,__constrange(0,1) int]\", vals = [PtrVal [],ArrayVal [VectorVal [FloatVal 0.5824678540229797,FloatVal 6.351560354232788e-2],VectorVal [FloatVal 7.760894298553467e-2,FloatVal 8.464819192886353e-2]],IndexVal 0], start_saturated = False}";
      int reported = 0;
      arg2.val[0] = vcreate_f32(UINT64_C(0x3d8214783f151c9d));
      arg2.val[1] = vcreate_f32(UINT64_C(0x3dad5c083d9ef170));
      clear_neon_saturated();
      vst2_lane_f32(result, arg2, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = result[0];
         exp = ((float32_t) 0.5824678540229797);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 0 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = result[1];
         exp = ((float32_t) 7.760894298553467e-2);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 1 ", exp, got);
            }
      }
   }
}
}
void dotests_1679() {

{
   {
      float64x1x2_t arg2;
      float64_t result[2];
      char* str1 = "ReproInfo2 {semantics = \"store2_lane\", fnname = \"vst2_lane_f64\", rettype = \"__transfersize(2) float64_t *\", argtypes = \"[/* result holder */,float64x1x2_t,__constrange(0,0) int]\", vals = [PtrVal [],ArrayVal [VectorVal [FloatVal 0.51758071655328],VectorVal [FloatVal 0.7989955992788381]],IndexVal 0], start_saturated = False}";
      int reported = 0;
      arg2.val[0] = vcreate_f64(UINT64_C(0x3fe090056f545ee4));
      arg2.val[1] = vcreate_f64(UINT64_C(0x3fe9915f38119df3));
      clear_neon_saturated();
      vst2_lane_f64(result, arg2, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float64_t got;
         float64_t exp;
         got = result[0];
         exp = 0.51758071655328;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 0 ", exp, got);
            }
      }
      {
         float64_t got;
         float64_t exp;
         got = result[1];
         exp = 0.7989955992788381;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 1 ", exp, got);
            }
      }
   }
}
}
void dotests_1680() {

{
   {
      poly8x8x2_t arg2;
      poly8_t result[2];
      char* str1 = "ReproInfo2 {semantics = \"store2_lane\", fnname = \"vst2_lane_p8\", rettype = \"__transfersize(2) poly8_t *\", argtypes = \"[/* result holder */,poly8x8x2_t,__constrange(0,7) int]\", vals = [PtrVal [],ArrayVal [VectorVal [PolyVal [1,0,0,1,0,0,0,0],PolyVal [0,1,1,1,1,1,0,0],PolyVal [1,1,1,0,1,1,1,1],PolyVal [0,0,1,0,1,0,1,0],PolyVal [0,1,1,1,1,1,1,1],PolyVal [1,0,0,0,0,1,1,1],PolyVal [1,0,0,0,1,1,1,0],PolyVal [0,0,1,1,0,1,1,0]],VectorVal [PolyVal [0,1,0,1,1,1,1,1],PolyVal [0,1,1,0,0,1,0,1],PolyVal [1,0,0,1,1,0,1,1],PolyVal [0,0,1,1,0,0,0,1],PolyVal [0,1,0,0,1,1,1,1],PolyVal [1,0,0,1,1,0,1,0],PolyVal [0,1,0,0,1,0,1,1],PolyVal [0,1,1,0,1,0,0,1]]],IndexVal 2], start_saturated = False}";
      int reported = 0;
      arg2.val[0] = vcreate_p8(UINT64_C(0x6c71e1fe54f73e09));
      arg2.val[1] = vcreate_p8(UINT64_C(0x96d259f28cd9a6fa));
      clear_neon_saturated();
      vst2_lane_p8(result, arg2, 2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         poly8_t got;
         poly8_t exp;
         got = result[0];
         exp = 247;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 0 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[1];
         exp = 217;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 1 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1681() {

{
   {
      poly16x4x2_t arg2;
      poly16_t result[2];
      char* str1 = "ReproInfo2 {semantics = \"store2_lane\", fnname = \"vst2_lane_p16\", rettype = \"__transfersize(2) poly16_t *\", argtypes = \"[/* result holder */,poly16x4x2_t,__constrange(0,3) int]\", vals = [PtrVal [],ArrayVal [VectorVal [PolyVal [1,1,0,1,0,0,1,1,0,1,0,0,1,1,1,1],PolyVal [0,1,1,1,0,0,0,0,0,1,0,0,0,1,0,1],PolyVal [0,1,0,1,1,1,0,0,1,0,1,1,0,0,0,1],PolyVal [0,1,1,0,0,1,1,0,0,1,0,1,1,1,1,0]],VectorVal [PolyVal [1,0,1,1,0,0,1,1,0,0,0,0,1,1,0,1],PolyVal [1,1,1,0,0,1,0,0,0,0,0,1,1,1,1,0],PolyVal [1,0,1,0,0,0,0,1,0,1,0,1,0,1,0,0],PolyVal [0,1,1,0,0,0,1,1,0,0,1,0,0,0,0,0]]],IndexVal 2], start_saturated = False}";
      int reported = 0;
      arg2.val[0] = vcreate_p16(UINT64_C(0x7a668d3aa20ef2cb));
      arg2.val[1] = vcreate_p16(UINT64_C(0x04c62a857827b0cd));
      clear_neon_saturated();
      vst2_lane_p16(result, arg2, 2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         poly16_t got;
         poly16_t exp;
         got = result[0];
         exp = 36154;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 0 ",
                      exp,
                      got);
            }
      }
      {
         poly16_t got;
         poly16_t exp;
         got = result[1];
         exp = 10885;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 1 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1682() {
#if __ARM_NEON_FP16_INTRINSICS

{
   {
      float16x4x2_t arg2;
      __fp16 result[2];
      char* str1 = "ReproInfo2 {semantics = \"store2_lane\", fnname = \"vst2_lane_f16\", rettype = \"__transfersize(2) __fp16 *\", argtypes = \"[/* result holder */,float16x4x2_t,__constrange(0,3) int]\", vals = [PtrVal [],ArrayVal [VectorVal [FloatVal 8.051206744180877,FloatVal 8.83863468653901,FloatVal (-4.831769143690778),FloatVal (-1.1513857269076606)],VectorVal [FloatVal 4.382135753394765,FloatVal (-0.27730620412042484),FloatVal (-2.584410646646882),FloatVal 7.567681789679604]],IndexVal 1], start_saturated = False}";
      int reported = 0;
      arg2.val[0] = vcreate_f16(UINT64_C(0xbc9bc4d4486b4806));
      arg2.val[1] = vcreate_f16(UINT64_C(0x4791c12bb46f4461));
      clear_neon_saturated();
      vst2_lane_f16(result, arg2, 1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         __fp16 got;
         __fp16 exp;
         got = result[0];
         exp = 8.83863468653901;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 0 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = result[1];
         exp = -0.27730620412042484;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 1 ", exp, got);
            }
      }
   }
}
#endif
}
void dotests_1683() {

{
   {
      uint64x1x2_t arg2;
      uint64_t result[2];
      char* str1 = "ReproInfo2 {semantics = \"store2_lane\", fnname = \"vst2_lane_u64\", rettype = \"__transfersize(2) uint64_t *\", argtypes = \"[/* result holder */,uint64x1x2_t,__constrange(0,0) int]\", vals = [PtrVal [],ArrayVal [VectorVal [IntegerVal 9223653509074540059],VectorVal [IntegerVal 9223289541270372352]],IndexVal 0], start_saturated = False}";
      int reported = 0;
      arg2.val[0] = vcreate_u64(UINT64_C(0x8000ffff5bac561b));
      arg2.val[1] = vcreate_u64(UINT64_C(0x7fffb4f87fff0000));
      clear_neon_saturated();
      vst2_lane_u64(result, arg2, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = result[0];
         exp = UINT64_C(0x8000ffff5bac561b);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Elem 0 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = result[1];
         exp = UINT64_C(0x7fffb4f87fff0000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Elem 1 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1684() {

{
   {
      int64x1x2_t arg2;
      int64_t result[2];
      char* str1 = "ReproInfo2 {semantics = \"store2_lane\", fnname = \"vst2_lane_s64\", rettype = \"__transfersize(2) int64_t *\", argtypes = \"[/* result holder */,int64x1x2_t,__constrange(0,0) int]\", vals = [PtrVal [],ArrayVal [VectorVal [IntegerVal (-9223128556338544640)],VectorVal [IntegerVal (-212448409812993)]],IndexVal 0], start_saturated = False}";
      int reported = 0;
      arg2.val[0] = vcreate_s64(UINT64_C(0x8000dd71b9ae0000));
      arg2.val[1] = vcreate_s64(UINT64_C(0xffff3ec77fffffff));
      clear_neon_saturated();
      vst2_lane_s64(result, arg2, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         int64_t got;
         int64_t exp;
         got = result[0];
         exp = INT64_C(-9223128556338544640);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi64 " Got: %" PRIi64 "\n",
                      "   Elem 0 ",
                      exp,
                      got);
            }
      }
      {
         int64_t got;
         int64_t exp;
         got = result[1];
         exp = INT64_C(-212448409812993);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi64 " Got: %" PRIi64 "\n",
                      "   Elem 1 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1685() {

{
   {
      poly64x1x2_t arg2;
      poly64_t result[2];
      char* str1 = "ReproInfo2 {semantics = \"store2_lane\", fnname = \"vst2_lane_p64\", rettype = \"__transfersize(2) poly64_t *\", argtypes = \"[/* result holder */,poly64x1x2_t,__constrange(0,0) int]\", vals = [PtrVal [],ArrayVal [VectorVal [PolyVal [0,0,0,0,0,1,0,1,0,1,1,0,1,0,0,0,1,1,1,1,1,1,1,1,0,1,0,0,1,1,0,1,0,0,1,1,1,1,1,1,1,1,1,0,1,1,1,0,0,0,1,1,1,0,1,1,1,0,1,0,0,1,0,1]],VectorVal [PolyVal [1,0,0,1,1,1,0,1,0,0,0,1,1,1,1,0,1,0,0,0,1,0,1,1,1,1,0,1,0,0,0,0,1,0,0,1,1,1,0,0,0,0,1,0,0,1,0,1,1,0,1,0,1,1,0,0,1,0,1,1,0,1,0,0]]],IndexVal 0], start_saturated = False}";
      int reported = 0;
      arg2.val[0] = vcreate_p64(UINT64_C(0xa5dc77fcb2ff16a0));
      arg2.val[1] = vcreate_p64(UINT64_C(0x2d35a4390bd178b9));
      clear_neon_saturated();
      vst2_lane_p64(result, arg2, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         poly64_t got;
         poly64_t exp;
         got = result[0];
         exp = -6495184635356572000;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu64 " Got: %" PRIu64 "\n",
                      "   Elem 0 ",
                      exp,
                      got);
            }
      }
      {
         poly64_t got;
         poly64_t exp;
         got = result[1];
         exp = 3257690470390790329;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu64 " Got: %" PRIu64 "\n",
                      "   Elem 1 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1686() {

{
   {
      uint8x16x3_t arg2;
      uint8_t result[3];
      char* str1 = "ReproInfo2 {semantics = \"store3_lane\", fnname = \"vst3q_lane_u8\", rettype = \"__transfersize(3) uint8_t *\", argtypes = \"[/* result holder */,uint8x16x3_t,__constrange(0,15) int]\", vals = [PtrVal [],ArrayVal [VectorVal [IntegerVal 0,IntegerVal 127,IntegerVal 38,IntegerVal 128,IntegerVal 127,IntegerVal 127,IntegerVal 128,IntegerVal 128,IntegerVal 255,IntegerVal 127,IntegerVal 128,IntegerVal 128,IntegerVal 127,IntegerVal 127,IntegerVal 0,IntegerVal 127],VectorVal [IntegerVal 51,IntegerVal 0,IntegerVal 128,IntegerVal 127,IntegerVal 201,IntegerVal 83,IntegerVal 255,IntegerVal 127,IntegerVal 128,IntegerVal 255,IntegerVal 255,IntegerVal 128,IntegerVal 128,IntegerVal 127,IntegerVal 255,IntegerVal 30],VectorVal [IntegerVal 155,IntegerVal 255,IntegerVal 219,IntegerVal 128,IntegerVal 128,IntegerVal 235,IntegerVal 0,IntegerVal 127,IntegerVal 0,IntegerVal 127,IntegerVal 128,IntegerVal 255,IntegerVal 128,IntegerVal 127,IntegerVal 127,IntegerVal 255]],IndexVal 7], start_saturated = False}";
      int reported = 0;
      arg2.val[0] = vcombine_u8(vcreate_u8(UINT64_C(0x80807f7f80267f00)),
                                vcreate_u8(UINT64_C(0x7f007f7f80807fff)));
      arg2.val[1] = vcombine_u8(vcreate_u8(UINT64_C(0x7fff53c97f800033)),
                                vcreate_u8(UINT64_C(0x1eff7f8080ffff80)));
      arg2.val[2] = vcombine_u8(vcreate_u8(UINT64_C(0x7f00eb8080dbff9b)),
                                vcreate_u8(UINT64_C(0xff7f7f80ff807f00)));
      clear_neon_saturated();
      vst3q_lane_u8(result, arg2, 7);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint8_t got;
         uint8_t exp;
         got = result[0];
         exp = 128U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 0 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[1];
         exp = 127U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 1 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[2];
         exp = 127U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 2 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1687() {

{
   {
      uint16x8x3_t arg2;
      uint16_t result[3];
      char* str1 = "ReproInfo2 {semantics = \"store3_lane\", fnname = \"vst3q_lane_u16\", rettype = \"__transfersize(3) uint16_t *\", argtypes = \"[/* result holder */,uint16x8x3_t,__constrange(0,7) int]\", vals = [PtrVal [],ArrayVal [VectorVal [IntegerVal 32767,IntegerVal 32767,IntegerVal 0,IntegerVal 32768,IntegerVal 32767,IntegerVal 65535,IntegerVal 32767,IntegerVal 32768],VectorVal [IntegerVal 32767,IntegerVal 65535,IntegerVal 32768,IntegerVal 0,IntegerVal 13642,IntegerVal 32768,IntegerVal 32768,IntegerVal 32002],VectorVal [IntegerVal 32768,IntegerVal 65535,IntegerVal 0,IntegerVal 0,IntegerVal 32768,IntegerVal 0,IntegerVal 0,IntegerVal 20302]],IndexVal 2], start_saturated = False}";
      int reported = 0;
      arg2.val[0] = vcombine_u16(vcreate_u16(UINT64_C(0x800000007fff7fff)),
                                 vcreate_u16(UINT64_C(0x80007fffffff7fff)));
      arg2.val[1] = vcombine_u16(vcreate_u16(UINT64_C(0x00008000ffff7fff)),
                                 vcreate_u16(UINT64_C(0x7d0280008000354a)));
      arg2.val[2] = vcombine_u16(vcreate_u16(UINT64_C(0x00000000ffff8000)),
                                 vcreate_u16(UINT64_C(0x4f4e000000008000)));
      clear_neon_saturated();
      vst3q_lane_u16(result, arg2, 2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint16_t got;
         uint16_t exp;
         got = result[0];
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 0 ",
                      exp,
                      got);
            }
      }
      {
         uint16_t got;
         uint16_t exp;
         got = result[1];
         exp = 32768U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 1 ",
                      exp,
                      got);
            }
      }
      {
         uint16_t got;
         uint16_t exp;
         got = result[2];
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 2 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1688() {

{
   {
      uint32x4x3_t arg2;
      uint32_t result[3];
      char* str1 = "ReproInfo2 {semantics = \"store3_lane\", fnname = \"vst3q_lane_u32\", rettype = \"__transfersize(3) uint32_t *\", argtypes = \"[/* result holder */,uint32x4x3_t,__constrange(0,3) int]\", vals = [PtrVal [],ArrayVal [VectorVal [IntegerVal 65535,IntegerVal 4278550527,IntegerVal 2147549183,IntegerVal 4294934528],VectorVal [IntegerVal 4294967295,IntegerVal 2147450879,IntegerVal 2147516416,IntegerVal 2147516416],VectorVal [IntegerVal 1151336448,IntegerVal 65535,IntegerVal 3679918899,IntegerVal 2147544164]],IndexVal 1], start_saturated = False}";
      int reported = 0;
      arg2.val[0] = vcombine_u32(vcreate_u32(UINT64_C(0xff057fff0000ffff)),
                                 vcreate_u32(UINT64_C(0xffff80008000ffff)));
      arg2.val[1] = vcombine_u32(vcreate_u32(UINT64_C(0x7fff7fffffffffff)),
                                 vcreate_u32(UINT64_C(0x8000800080008000)));
      arg2.val[2] = vcombine_u32(vcreate_u32(UINT64_C(0x0000ffff44a00000)),
                                 vcreate_u32(UINT64_C(0x8000ec64db571b33)));
      clear_neon_saturated();
      vst3q_lane_u32(result, arg2, 1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint32_t got;
         uint32_t exp;
         got = result[0];
         exp = 4278550527U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu32 " Got: %" PRIu32 "\n",
                      "   Elem 0 ",
                      exp,
                      got);
            }
      }
      {
         uint32_t got;
         uint32_t exp;
         got = result[1];
         exp = 2147450879U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu32 " Got: %" PRIu32 "\n",
                      "   Elem 1 ",
                      exp,
                      got);
            }
      }
      {
         uint32_t got;
         uint32_t exp;
         got = result[2];
         exp = 65535U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu32 " Got: %" PRIu32 "\n",
                      "   Elem 2 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1689() {

{
   {
      int8x16x3_t arg2;
      int8_t result[3];
      char* str1 = "ReproInfo2 {semantics = \"store3_lane\", fnname = \"vst3q_lane_s8\", rettype = \"__transfersize(3) int8_t *\", argtypes = \"[/* result holder */,int8x16x3_t,__constrange(0,15) int]\", vals = [PtrVal [],ArrayVal [VectorVal [IntegerVal 127,IntegerVal 0,IntegerVal (-13),IntegerVal (-1),IntegerVal (-1),IntegerVal (-1),IntegerVal 0,IntegerVal 127,IntegerVal 0,IntegerVal (-1),IntegerVal (-128),IntegerVal (-1),IntegerVal (-1),IntegerVal 127,IntegerVal 0,IntegerVal (-128)],VectorVal [IntegerVal (-1),IntegerVal 127,IntegerVal (-1),IntegerVal 127,IntegerVal 0,IntegerVal (-1),IntegerVal 79,IntegerVal 67,IntegerVal 0,IntegerVal (-1),IntegerVal (-128),IntegerVal 127,IntegerVal 127,IntegerVal (-128),IntegerVal 77,IntegerVal (-128)],VectorVal [IntegerVal (-1),IntegerVal (-1),IntegerVal 0,IntegerVal 127,IntegerVal 127,IntegerVal (-102),IntegerVal 1,IntegerVal 127,IntegerVal (-81),IntegerVal (-123),IntegerVal (-1),IntegerVal 127,IntegerVal 0,IntegerVal (-1),IntegerVal (-14),IntegerVal 0]],IndexVal 13], start_saturated = False}";
      int reported = 0;
      arg2.val[0] = vcombine_s8(vcreate_s8(UINT64_C(0x7f00fffffff3007f)),
                                vcreate_s8(UINT64_C(0x80007fffff80ff00)));
      arg2.val[1] = vcombine_s8(vcreate_s8(UINT64_C(0x434fff007fff7fff)),
                                vcreate_s8(UINT64_C(0x804d807f7f80ff00)));
      arg2.val[2] = vcombine_s8(vcreate_s8(UINT64_C(0x7f019a7f7f00ffff)),
                                vcreate_s8(UINT64_C(0x00f2ff007fff85af)));
      clear_neon_saturated();
      vst3q_lane_s8(result, arg2, 13);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         int8_t got;
         int8_t exp;
         got = result[0];
         exp = 127;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 0 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[1];
         exp = -128;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 1 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[2];
         exp = -1;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 2 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1690() {

{
   {
      int16x8x3_t arg2;
      int16_t result[3];
      char* str1 = "ReproInfo2 {semantics = \"store3_lane\", fnname = \"vst3q_lane_s16\", rettype = \"__transfersize(3) int16_t *\", argtypes = \"[/* result holder */,int16x8x3_t,__constrange(0,7) int]\", vals = [PtrVal [],ArrayVal [VectorVal [IntegerVal (-32768),IntegerVal 0,IntegerVal 0,IntegerVal 0,IntegerVal 32767,IntegerVal 0,IntegerVal 0,IntegerVal (-1)],VectorVal [IntegerVal (-32768),IntegerVal 32767,IntegerVal (-32768),IntegerVal 0,IntegerVal (-1),IntegerVal 32588,IntegerVal 32767,IntegerVal 32767],VectorVal [IntegerVal 32767,IntegerVal (-15929),IntegerVal 32767,IntegerVal (-32768),IntegerVal (-32768),IntegerVal 32767,IntegerVal (-32768),IntegerVal (-32768)]],IndexVal 0], start_saturated = False}";
      int reported = 0;
      arg2.val[0] = vcombine_s16(vcreate_s16(UINT64_C(0x0000000000008000)),
                                 vcreate_s16(UINT64_C(0xffff000000007fff)));
      arg2.val[1] = vcombine_s16(vcreate_s16(UINT64_C(0x000080007fff8000)),
                                 vcreate_s16(UINT64_C(0x7fff7fff7f4cffff)));
      arg2.val[2] = vcombine_s16(vcreate_s16(UINT64_C(0x80007fffc1c77fff)),
                                 vcreate_s16(UINT64_C(0x800080007fff8000)));
      clear_neon_saturated();
      vst3q_lane_s16(result, arg2, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         int16_t got;
         int16_t exp;
         got = result[0];
         exp = -32768;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi16 " Got: %" PRIi16 "\n",
                      "   Elem 0 ",
                      exp,
                      got);
            }
      }
      {
         int16_t got;
         int16_t exp;
         got = result[1];
         exp = -32768;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi16 " Got: %" PRIi16 "\n",
                      "   Elem 1 ",
                      exp,
                      got);
            }
      }
      {
         int16_t got;
         int16_t exp;
         got = result[2];
         exp = 32767;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi16 " Got: %" PRIi16 "\n",
                      "   Elem 2 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1691() {

{
   {
      int32x4x3_t arg2;
      int32_t result[3];
      char* str1 = "ReproInfo2 {semantics = \"store3_lane\", fnname = \"vst3q_lane_s32\", rettype = \"__transfersize(3) int32_t *\", argtypes = \"[/* result holder */,int32x4x3_t,__constrange(0,3) int]\", vals = [PtrVal [],ArrayVal [VectorVal [IntegerVal (-2147450881),IntegerVal (-2147483648),IntegerVal (-2147418113),IntegerVal (-711655424)],VectorVal [IntegerVal 18621,IntegerVal 2147450880,IntegerVal (-2147419005),IntegerVal 1624801279],VectorVal [IntegerVal 2147483447,IntegerVal (-1421377536),IntegerVal (-2147450881),IntegerVal (-60934)]],IndexVal 0], start_saturated = False}";
      int reported = 0;
      arg2.val[0] = vcombine_s32(vcreate_s32(UINT64_C(0x8000000080007fff)),
                                 vcreate_s32(UINT64_C(0xd59500008000ffff)));
      arg2.val[1] = vcombine_s32(vcreate_s32(UINT64_C(0x7fff8000000048bd)),
                                 vcreate_s32(UINT64_C(0x60d87fff8000fc83)));
      arg2.val[2] = vcombine_s32(vcreate_s32(UINT64_C(0xab4780007fffff37)),
                                 vcreate_s32(UINT64_C(0xffff11fa80007fff)));
      clear_neon_saturated();
      vst3q_lane_s32(result, arg2, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         int32_t got;
         int32_t exp;
         got = result[0];
         exp = -2147450881;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi32 " Got: %" PRIi32 "\n",
                      "   Elem 0 ",
                      exp,
                      got);
            }
      }
      {
         int32_t got;
         int32_t exp;
         got = result[1];
         exp = 18621;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi32 " Got: %" PRIi32 "\n",
                      "   Elem 1 ",
                      exp,
                      got);
            }
      }
      {
         int32_t got;
         int32_t exp;
         got = result[2];
         exp = 2147483447;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi32 " Got: %" PRIi32 "\n",
                      "   Elem 2 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1692() {

{
   {
      float32x4x3_t arg2;
      float32_t result[3];
      char* str1 = "ReproInfo2 {semantics = \"store3_lane\", fnname = \"vst3q_lane_f32\", rettype = \"__transfersize(3) float32_t *\", argtypes = \"[/* result holder */,float32x4x3_t,__constrange(0,3) int]\", vals = [PtrVal [],ArrayVal [VectorVal [FloatVal 0.573702871799469,FloatVal 5.153775215148926e-3,FloatVal 0.8552990555763245,FloatVal 0.4114323854446411],VectorVal [FloatVal 0.6238747835159302,FloatVal 0.3172423839569092,FloatVal 2.9507994651794434e-2,FloatVal 0.45419061183929443],VectorVal [FloatVal 0.12271267175674438,FloatVal 8.832335472106934e-3,FloatVal 7.60696530342102e-2,FloatVal 5.967426300048828e-2]],IndexVal 2], start_saturated = False}";
      int reported = 0;
      arg2.val[0] = vcombine_f32(vcreate_f32(UINT64_C(0x3ba8e1003f12de31)),
                                 vcreate_f32(UINT64_C(0x3ed2a7443f5af4e1)));
      arg2.val[1] = vcombine_f32(vcreate_f32(UINT64_C(0x3ea26d983f1fb642)),
                                 vcreate_f32(UINT64_C(0x3ee88bac3cf1bac0)));
      arg2.val[2] = vcombine_f32(vcreate_f32(UINT64_C(0x3c10b5803dfb50c8)),
                                 vcreate_f32(UINT64_C(0x3d746d003d9bca68)));
      clear_neon_saturated();
      vst3q_lane_f32(result, arg2, 2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = result[0];
         exp = ((float32_t) 0.8552990555763245);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 0 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = result[1];
         exp = ((float32_t) 2.9507994651794434e-2);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 1 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = result[2];
         exp = ((float32_t) 7.60696530342102e-2);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 2 ", exp, got);
            }
      }
   }
}
}
void dotests_1693() {

{
   {
      float64x2x3_t arg2;
      float64_t result[3];
      char* str1 = "ReproInfo2 {semantics = \"store3_lane\", fnname = \"vst3q_lane_f64\", rettype = \"__transfersize(3) float64_t *\", argtypes = \"[/* result holder */,float64x2x3_t,__constrange(0,1) int]\", vals = [PtrVal [],ArrayVal [VectorVal [FloatVal 0.7455873472871579,FloatVal 0.8803591630600491],VectorVal [FloatVal 0.7694012177311202,FloatVal 0.41576378904664824],VectorVal [FloatVal 0.8956518941168718,FloatVal 0.4455217478865806]],IndexVal 1], start_saturated = False}";
      int reported = 0;
      arg2.val[0] = vcombine_f64(vcreate_f64(UINT64_C(0x3fe7dbd9ff1d1c92)),
                                 vcreate_f64(UINT64_C(0x3fec2be6fac2757e)));
      arg2.val[1] = vcombine_f64(vcreate_f64(UINT64_C(0x3fe89eef4d750c2e)),
                                 vcreate_f64(UINT64_C(0x3fda9bdfb9343fda)));
      arg2.val[2] = vcombine_f64(vcreate_f64(UINT64_C(0x3feca92e293aa32e)),
                                 vcreate_f64(UINT64_C(0x3fdc836da6351882)));
      clear_neon_saturated();
      vst3q_lane_f64(result, arg2, 1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float64_t got;
         float64_t exp;
         got = result[0];
         exp = 0.8803591630600491;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 0 ", exp, got);
            }
      }
      {
         float64_t got;
         float64_t exp;
         got = result[1];
         exp = 0.41576378904664824;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 1 ", exp, got);
            }
      }
      {
         float64_t got;
         float64_t exp;
         got = result[2];
         exp = 0.4455217478865806;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 2 ", exp, got);
            }
      }
   }
}
}
void dotests_1694() {

{
   {
      poly8x16x3_t arg2;
      poly8_t result[3];
      char* str1 = "ReproInfo2 {semantics = \"store3_lane\", fnname = \"vst3q_lane_p8\", rettype = \"__transfersize(3) poly8_t *\", argtypes = \"[/* result holder */,poly8x16x3_t,__constrange(0,15) int]\", vals = [PtrVal [],ArrayVal [VectorVal [PolyVal [1,1,0,0,0,1,1,1],PolyVal [0,1,1,0,1,0,1,1],PolyVal [0,0,1,0,0,1,0,0],PolyVal [1,1,1,0,0,0,0,0],PolyVal [0,1,0,1,0,0,0,1],PolyVal [0,0,0,1,0,0,0,1],PolyVal [1,0,0,0,1,0,0,0],PolyVal [0,0,1,1,0,1,0,0],PolyVal [1,1,0,0,0,0,0,0],PolyVal [0,0,0,1,1,0,0,0],PolyVal [1,1,0,1,1,0,1,0],PolyVal [0,0,1,1,0,1,1,1],PolyVal [1,1,1,0,1,1,0,0],PolyVal [0,0,0,1,0,0,1,1],PolyVal [0,1,0,0,1,0,1,0],PolyVal [1,0,1,0,1,0,1,0]],VectorVal [PolyVal [1,0,1,1,1,0,0,1],PolyVal [1,1,1,0,1,1,0,1],PolyVal [1,0,1,0,0,1,0,0],PolyVal [0,0,0,0,1,0,1,0],PolyVal [0,0,0,0,0,1,1,0],PolyVal [0,0,0,0,0,1,0,0],PolyVal [1,0,1,1,0,1,1,0],PolyVal [1,0,1,1,1,0,1,0],PolyVal [1,1,1,0,1,0,0,1],PolyVal [0,1,1,0,1,0,1,0],PolyVal [0,0,0,0,0,0,0,0],PolyVal [1,1,0,1,1,1,0,1],PolyVal [0,0,1,0,1,1,0,0],PolyVal [1,1,1,0,0,0,0,0],PolyVal [0,0,1,0,0,0,1,0],PolyVal [0,1,0,0,1,0,0,1]],VectorVal [PolyVal [1,1,0,1,0,1,1,1],PolyVal [0,1,0,0,0,0,1,0],PolyVal [0,1,1,1,1,1,0,1],PolyVal [1,1,1,0,0,0,1,0],PolyVal [0,0,1,0,1,0,0,0],PolyVal [0,0,0,0,1,0,0,1],PolyVal [0,0,0,1,0,0,1,0],PolyVal [1,1,1,0,0,0,1,1],PolyVal [1,1,0,1,1,1,1,0],PolyVal [1,0,0,0,0,0,0,0],PolyVal [1,0,1,1,0,0,1,1],PolyVal [1,0,1,0,1,0,1,1],PolyVal [1,0,0,0,1,0,1,1],PolyVal [0,1,0,0,1,0,1,1],PolyVal [0,0,0,0,1,0,0,1],PolyVal [1,1,1,1,1,1,1,1]]],IndexVal 15], start_saturated = False}";
      int reported = 0;
      arg2.val[0] = vcombine_p8(vcreate_p8(UINT64_C(0x2c11888a0724d6e3)),
                                vcreate_p8(UINT64_C(0x5552c837ec5b1803)));
      arg2.val[1] = vcombine_p8(vcreate_p8(UINT64_C(0x5d6d20605025b79d)),
                                vcreate_p8(UINT64_C(0x92440734bb005697)));
      arg2.val[2] = vcombine_p8(vcreate_p8(UINT64_C(0xc748901447be42eb)),
                                vcreate_p8(UINT64_C(0xff90d2d1d5cd017b)));
      clear_neon_saturated();
      vst3q_lane_p8(result, arg2, 15);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         poly8_t got;
         poly8_t exp;
         got = result[0];
         exp = 85;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 0 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[1];
         exp = 146;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 1 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[2];
         exp = 255;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 2 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1695() {

{
   {
      poly16x8x3_t arg2;
      poly16_t result[3];
      char* str1 = "ReproInfo2 {semantics = \"store3_lane\", fnname = \"vst3q_lane_p16\", rettype = \"__transfersize(3) poly16_t *\", argtypes = \"[/* result holder */,poly16x8x3_t,__constrange(0,7) int]\", vals = [PtrVal [],ArrayVal [VectorVal [PolyVal [1,1,1,1,1,1,1,0,0,1,1,0,1,1,1,0],PolyVal [0,0,0,0,0,1,0,0,1,0,0,0,0,0,1,1],PolyVal [1,0,0,1,0,0,1,1,0,1,1,1,0,1,1,0],PolyVal [1,1,1,1,1,1,1,0,0,1,1,0,1,1,1,1],PolyVal [0,1,1,1,0,0,0,1,1,1,0,1,1,1,1,1],PolyVal [1,1,0,0,0,0,1,1,0,0,1,0,1,0,0,1],PolyVal [1,0,1,0,0,1,0,1,1,0,1,0,0,0,1,1],PolyVal [0,1,1,0,0,1,1,0,0,1,1,0,0,0,0,0]],VectorVal [PolyVal [1,1,0,1,0,0,0,1,1,1,0,0,1,0,0,1],PolyVal [1,0,1,0,1,0,0,1,1,0,0,0,0,1,0,1],PolyVal [1,0,1,1,0,0,0,1,0,1,0,1,1,0,1,1],PolyVal [1,0,0,0,0,1,1,0,0,1,0,1,0,0,1,0],PolyVal [0,1,1,1,0,1,0,1,1,1,1,1,0,1,0,1],PolyVal [0,0,0,1,0,1,1,0,0,0,1,1,1,1,1,1],PolyVal [1,1,1,1,1,0,0,0,0,0,0,1,1,1,1,0],PolyVal [0,0,1,1,1,1,1,0,0,0,0,0,1,1,0,0]],VectorVal [PolyVal [0,0,0,0,1,0,1,0,0,0,0,1,1,1,0,1],PolyVal [1,1,1,1,1,1,1,1,0,1,0,0,0,1,0,1],PolyVal [0,0,1,1,1,1,0,0,0,1,0,0,1,1,0,0],PolyVal [1,0,1,1,1,1,0,1,0,0,1,1,0,0,0,1],PolyVal [1,1,0,0,0,0,1,1,0,1,0,1,0,1,0,1],PolyVal [0,1,1,1,0,0,0,1,0,1,1,1,0,1,1,1],PolyVal [1,0,1,1,0,0,1,0,1,1,0,1,0,1,0,0],PolyVal [0,1,1,0,0,1,0,0,1,1,1,0,0,1,1,0]]],IndexVal 0], start_saturated = True}";
      int reported = 0;
      arg2.val[0] = vcombine_p16(vcreate_p16(UINT64_C(0xf67f6ec9c120767f)),
                                 vcreate_p16(UINT64_C(0x0666c5a594c3fb8e)));
      arg2.val[1] = vcombine_p16(vcreate_p16(UINT64_C(0x4a61da8da195938b)),
                                 vcreate_p16(UINT64_C(0x307c781ffc68afae)));
      arg2.val[2] = vcombine_p16(vcreate_p16(UINT64_C(0x8cbd323ca2ffb850)),
                                 vcreate_p16(UINT64_C(0x67262b4dee8eaac3)));
      set_neon_saturated();
      vst3q_lane_p16(result, arg2, 0);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      {
         poly16_t got;
         poly16_t exp;
         got = result[0];
         exp = 30335;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 0 ",
                      exp,
                      got);
            }
      }
      {
         poly16_t got;
         poly16_t exp;
         got = result[1];
         exp = 37771;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 1 ",
                      exp,
                      got);
            }
      }
      {
         poly16_t got;
         poly16_t exp;
         got = result[2];
         exp = 47184;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 2 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1696() {
#if __ARM_NEON_FP16_INTRINSICS

{
   {
      float16x8x3_t arg2;
      __fp16 result[3];
      char* str1 = "ReproInfo2 {semantics = \"store3_lane\", fnname = \"vst3q_lane_f16\", rettype = \"__transfersize(3) __fp16 *\", argtypes = \"[/* result holder */,float16x8x3_t,__constrange(0,7) int]\", vals = [PtrVal [],ArrayVal [VectorVal [FloatVal 5.773123047182116,FloatVal (-3.350331801252655),FloatVal (-0.34688029964145883),FloatVal (-0.32443790050959365),FloatVal (-3.0935515007338266),FloatVal 8.052462860923985,FloatVal (-3.218148672288958),FloatVal (-5.186221989269953)],VectorVal [FloatVal (-5.615635160656609),FloatVal 3.497515086729063,FloatVal (-4.3679166213710685),FloatVal 6.6286214926580165,FloatVal (-6.022495012544534),FloatVal (-5.002267195025993),FloatVal (-6.186106724099451),FloatVal (-2.1731959274247714)],VectorVal [FloatVal 0.14619997292292553,FloatVal 5.374589076687965,FloatVal 5.597444600668734,FloatVal (-8.913773895859915),FloatVal 7.527118632617878,FloatVal 7.137222660178711,FloatVal 6.654938912520279,FloatVal (-8.927326558205282)]],IndexVal 4], start_saturated = False}";
      int reported = 0;
      arg2.val[0] = vcombine_f16(vcreate_f16(UINT64_C(0xb530b58cc2b345c5)),
                                 vcreate_f16(UINT64_C(0xc52fc26f4806c22f)));
      arg2.val[1] = vcombine_f16(vcreate_f16(UINT64_C(0x46a0c45e42fec59d)),
                                 vcreate_f16(UINT64_C(0xc058c62fc500c605)));
      arg2.val[2] = vcombine_f16(vcreate_f16(UINT64_C(0xc8744598455f30ad)),
                                 vcreate_f16(UINT64_C(0xc87646a747234786)));
      clear_neon_saturated();
      vst3q_lane_f16(result, arg2, 4);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         __fp16 got;
         __fp16 exp;
         got = result[0];
         exp = -3.0935515007338266;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 0 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = result[1];
         exp = -6.022495012544534;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 1 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = result[2];
         exp = 7.527118632617878;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 2 ", exp, got);
            }
      }
   }
}
#endif
}
void dotests_1697() {

{
   {
      uint64x2x3_t arg2;
      uint64_t result[3];
      char* str1 = "ReproInfo2 {semantics = \"store3_lane\", fnname = \"vst3q_lane_u64\", rettype = \"__transfersize(3) uint64_t *\", argtypes = \"[/* result holder */,uint64x2x3_t,__constrange(0,1) int]\", vals = [PtrVal [],ArrayVal [VectorVal [IntegerVal 65535,IntegerVal 9223653508842979327],VectorVal [IntegerVal 18446462598732873727,IntegerVal 9223231301513871360],VectorVal [IntegerVal 15326031011213443071,IntegerVal 9223231295071477954]],IndexVal 0], start_saturated = False}";
      int reported = 0;
      arg2.val[0] = vcombine_u64(vcreate_u64(UINT64_C(0x000000000000ffff)),
                                 vcreate_u64(UINT64_C(0x8000ffff4ddeffff)));
      arg2.val[1] = vcombine_u64(vcreate_u64(UINT64_C(0xffff000000007fff)),
                                 vcreate_u64(UINT64_C(0x7fff80007fff8000)));
      arg2.val[2] = vcombine_u64(vcreate_u64(UINT64_C(0xd4b10000ffff7fff)),
                                 vcreate_u64(UINT64_C(0x7fff7fff000060c2)));
      clear_neon_saturated();
      vst3q_lane_u64(result, arg2, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = result[0];
         exp = UINT64_C(0x000000000000ffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Elem 0 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = result[1];
         exp = UINT64_C(0xffff000000007fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Elem 1 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = result[2];
         exp = UINT64_C(0xd4b10000ffff7fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Elem 2 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1698() {

{
   {
      int64x2x3_t arg2;
      int64_t result[3];
      char* str1 = "ReproInfo2 {semantics = \"store3_lane\", fnname = \"vst3q_lane_s64\", rettype = \"__transfersize(3) int64_t *\", argtypes = \"[/* result holder */,int64x2x3_t,__constrange(0,1) int]\", vals = [PtrVal [],ArrayVal [VectorVal [IntegerVal 140733193402780,IntegerVal 140737488289792],VectorVal [IntegerVal 4481081624938741759,IntegerVal (-281472958038017)],VectorVal [IntegerVal (-647266304),IntegerVal (-9223090561878130688)]],IndexVal 0], start_saturated = False}";
      int reported = 0;
      arg2.val[0] = vcombine_s64(vcreate_s64(UINT64_C(0x00007fff0000399c)),
                                 vcreate_s64(UINT64_C(0x00007fffffff0000)));
      arg2.val[1] = vcombine_s64(vcreate_s64(UINT64_C(0x3e2fffff0000ffff)),
                                 vcreate_s64(UINT64_C(0xffff000078527fff)));
      arg2.val[2] = vcombine_s64(vcreate_s64(UINT64_C(0xffffffffd96b8000)),
                                 vcreate_s64(UINT64_C(0x8000ffffffff0000)));
      clear_neon_saturated();
      vst3q_lane_s64(result, arg2, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         int64_t got;
         int64_t exp;
         got = result[0];
         exp = INT64_C(140733193402780);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi64 " Got: %" PRIi64 "\n",
                      "   Elem 0 ",
                      exp,
                      got);
            }
      }
      {
         int64_t got;
         int64_t exp;
         got = result[1];
         exp = INT64_C(4481081624938741759);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi64 " Got: %" PRIi64 "\n",
                      "   Elem 1 ",
                      exp,
                      got);
            }
      }
      {
         int64_t got;
         int64_t exp;
         got = result[2];
         exp = INT64_C(-647266304);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi64 " Got: %" PRIi64 "\n",
                      "   Elem 2 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1699() {

{
   {
      poly64x2x3_t arg2;
      poly64_t result[3];
      char* str1 = "ReproInfo2 {semantics = \"store3_lane\", fnname = \"vst3q_lane_p64\", rettype = \"__transfersize(3) poly64_t *\", argtypes = \"[/* result holder */,poly64x2x3_t,__constrange(0,1) int]\", vals = [PtrVal [],ArrayVal [VectorVal [PolyVal [0,1,1,0,0,1,0,1,0,1,1,0,1,1,1,0,1,1,1,1,1,0,1,1,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,1,1,0,0,0,0,1,0,1,0,0,1,0],PolyVal [1,0,1,1,1,1,1,0,0,1,1,0,0,0,0,1,1,1,0,1,0,1,1,0,1,1,1,1,1,0,0,0,1,1,0,1,0,0,1,0,1,0,0,0,1,0,1,0,1,1,0,0,0,0,1,1,1,1,0,0,1,0,1,0]],VectorVal [PolyVal [0,1,0,0,0,0,0,1,1,0,0,1,0,0,1,0,1,0,1,0,1,0,0,1,0,0,0,1,0,1,1,1,0,1,0,0,1,1,1,1,0,0,0,1,0,1,1,1,0,1,0,0,1,0,0,1,0,0,1,1,1,1,0,0],PolyVal [0,0,1,0,0,0,0,0,1,1,1,0,1,0,1,0,1,1,0,0,0,0,0,1,0,0,0,1,1,1,0,1,1,1,0,0,0,0,1,0,1,0,0,1,1,0,0,1,0,1,1,1,0,1,1,0,0,1,1,0,1,0,0,0]],VectorVal [PolyVal [1,1,1,1,1,1,0,1,0,1,1,0,0,0,1,0,1,1,1,0,1,1,1,1,0,0,1,1,0,0,1,0,0,1,1,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,1,1,0,1,0,1,1,0,0,0,1,0,1,1],PolyVal [0,0,1,1,1,0,1,1,1,0,1,0,0,0,0,1,0,1,1,1,1,1,0,0,0,1,0,1,1,1,1,0,1,1,1,1,1,1,1,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,1,0,1,1,1,1,0,1,0]]],IndexVal 1], start_saturated = False}";
      int reported = 0;
      arg2.val[0] = vcombine_p64(vcreate_p64(UINT64_C(0x4a18150922df76a6)),
                                 vcreate_p64(UINT64_C(0x53c3514b1f6b867d)));
      arg2.val[1] = vcombine_p64(vcreate_p64(UINT64_C(0x3c92e8f2e8954982)),
                                 vcreate_p64(UINT64_C(0x166e9943b8835704)));
      arg2.val[2] = vcombine_p64(vcreate_p64(UINT64_C(0xd1ac24164cf746bf)),
                                 vcreate_p64(UINT64_C(0x5ec8217f7a3e85dc)));
      clear_neon_saturated();
      vst3q_lane_p64(result, arg2, 1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         poly64_t got;
         poly64_t exp;
         got = result[0];
         exp = 6035757308698134141;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu64 " Got: %" PRIu64 "\n",
                      "   Elem 0 ",
                      exp,
                      got);
            }
      }
      {
         poly64_t got;
         poly64_t exp;
         got = result[1];
         exp = 1616397832410060548;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu64 " Got: %" PRIu64 "\n",
                      "   Elem 1 ",
                      exp,
                      got);
            }
      }
      {
         poly64_t got;
         poly64_t exp;
         got = result[2];
         exp = 6829745666302838236;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu64 " Got: %" PRIu64 "\n",
                      "   Elem 2 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1700() {

{
   {
      uint8x8x3_t arg2;
      uint8_t result[3];
      char* str1 = "ReproInfo2 {semantics = \"store3_lane\", fnname = \"vst3_lane_u8\", rettype = \"__transfersize(3) uint8_t *\", argtypes = \"[/* result holder */,uint8x8x3_t,__constrange(0,7) int]\", vals = [PtrVal [],ArrayVal [VectorVal [IntegerVal 0,IntegerVal 127,IntegerVal 128,IntegerVal 0,IntegerVal 128,IntegerVal 255,IntegerVal 127,IntegerVal 127],VectorVal [IntegerVal 127,IntegerVal 128,IntegerVal 255,IntegerVal 127,IntegerVal 128,IntegerVal 0,IntegerVal 0,IntegerVal 127],VectorVal [IntegerVal 0,IntegerVal 255,IntegerVal 64,IntegerVal 127,IntegerVal 12,IntegerVal 230,IntegerVal 119,IntegerVal 127]],IndexVal 2], start_saturated = False}";
      int reported = 0;
      arg2.val[0] = vcreate_u8(UINT64_C(0x7f7fff8000807f00));
      arg2.val[1] = vcreate_u8(UINT64_C(0x7f0000807fff807f));
      arg2.val[2] = vcreate_u8(UINT64_C(0x7f77e60c7f40ff00));
      clear_neon_saturated();
      vst3_lane_u8(result, arg2, 2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint8_t got;
         uint8_t exp;
         got = result[0];
         exp = 128U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 0 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[1];
         exp = 255U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 1 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[2];
         exp = 64U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 2 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1701() {

{
   {
      uint16x4x3_t arg2;
      uint16_t result[3];
      char* str1 = "ReproInfo2 {semantics = \"store3_lane\", fnname = \"vst3_lane_u16\", rettype = \"__transfersize(3) uint16_t *\", argtypes = \"[/* result holder */,uint16x4x3_t,__constrange(0,3) int]\", vals = [PtrVal [],ArrayVal [VectorVal [IntegerVal 32768,IntegerVal 65535,IntegerVal 0,IntegerVal 32767],VectorVal [IntegerVal 32767,IntegerVal 32768,IntegerVal 32767,IntegerVal 32767],VectorVal [IntegerVal 65535,IntegerVal 65535,IntegerVal 65535,IntegerVal 32767]],IndexVal 1], start_saturated = False}";
      int reported = 0;
      arg2.val[0] = vcreate_u16(UINT64_C(0x7fff0000ffff8000));
      arg2.val[1] = vcreate_u16(UINT64_C(0x7fff7fff80007fff));
      arg2.val[2] = vcreate_u16(UINT64_C(0x7fffffffffffffff));
      clear_neon_saturated();
      vst3_lane_u16(result, arg2, 1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint16_t got;
         uint16_t exp;
         got = result[0];
         exp = 65535U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 0 ",
                      exp,
                      got);
            }
      }
      {
         uint16_t got;
         uint16_t exp;
         got = result[1];
         exp = 32768U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 1 ",
                      exp,
                      got);
            }
      }
      {
         uint16_t got;
         uint16_t exp;
         got = result[2];
         exp = 65535U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 2 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1702() {

{
   {
      uint32x2x3_t arg2;
      uint32_t result[3];
      char* str1 = "ReproInfo2 {semantics = \"store3_lane\", fnname = \"vst3_lane_u32\", rettype = \"__transfersize(3) uint32_t *\", argtypes = \"[/* result holder */,uint32x2x3_t,__constrange(0,1) int]\", vals = [PtrVal [],ArrayVal [VectorVal [IntegerVal 4294902812,IntegerVal 2147450880],VectorVal [IntegerVal 4294934527,IntegerVal 3745218560],VectorVal [IntegerVal 2147516415,IntegerVal 4294937456]],IndexVal 1], start_saturated = False}";
      int reported = 0;
      arg2.val[0] = vcreate_u32(UINT64_C(0x7fff8000ffff041c));
      arg2.val[1] = vcreate_u32(UINT64_C(0xdf3b8000ffff7fff));
      arg2.val[2] = vcreate_u32(UINT64_C(0xffff8b7080007fff));
      clear_neon_saturated();
      vst3_lane_u32(result, arg2, 1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint32_t got;
         uint32_t exp;
         got = result[0];
         exp = 2147450880U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu32 " Got: %" PRIu32 "\n",
                      "   Elem 0 ",
                      exp,
                      got);
            }
      }
      {
         uint32_t got;
         uint32_t exp;
         got = result[1];
         exp = 3745218560U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu32 " Got: %" PRIu32 "\n",
                      "   Elem 1 ",
                      exp,
                      got);
            }
      }
      {
         uint32_t got;
         uint32_t exp;
         got = result[2];
         exp = 4294937456U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu32 " Got: %" PRIu32 "\n",
                      "   Elem 2 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1703() {

{
   {
      int8x8x3_t arg2;
      int8_t result[3];
      char* str1 = "ReproInfo2 {semantics = \"store3_lane\", fnname = \"vst3_lane_s8\", rettype = \"__transfersize(3) int8_t *\", argtypes = \"[/* result holder */,int8x8x3_t,__constrange(0,7) int]\", vals = [PtrVal [],ArrayVal [VectorVal [IntegerVal (-19),IntegerVal (-128),IntegerVal (-128),IntegerVal 0,IntegerVal 53,IntegerVal 127,IntegerVal (-1),IntegerVal (-85)],VectorVal [IntegerVal 127,IntegerVal (-1),IntegerVal 127,IntegerVal (-1),IntegerVal (-128),IntegerVal 127,IntegerVal (-1),IntegerVal (-128)],VectorVal [IntegerVal (-1),IntegerVal 0,IntegerVal (-128),IntegerVal (-63),IntegerVal 127,IntegerVal (-128),IntegerVal (-1),IntegerVal (-1)]],IndexVal 2], start_saturated = False}";
      int reported = 0;
      arg2.val[0] = vcreate_s8(UINT64_C(0xabff7f35008080ed));
      arg2.val[1] = vcreate_s8(UINT64_C(0x80ff7f80ff7fff7f));
      arg2.val[2] = vcreate_s8(UINT64_C(0xffff807fc18000ff));
      clear_neon_saturated();
      vst3_lane_s8(result, arg2, 2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         int8_t got;
         int8_t exp;
         got = result[0];
         exp = -128;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 0 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[1];
         exp = 127;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 1 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[2];
         exp = -128;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 2 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1704() {

{
   {
      int16x4x3_t arg2;
      int16_t result[3];
      char* str1 = "ReproInfo2 {semantics = \"store3_lane\", fnname = \"vst3_lane_s16\", rettype = \"__transfersize(3) int16_t *\", argtypes = \"[/* result holder */,int16x4x3_t,__constrange(0,3) int]\", vals = [PtrVal [],ArrayVal [VectorVal [IntegerVal (-32768),IntegerVal 32767,IntegerVal 32767,IntegerVal 32767],VectorVal [IntegerVal (-1),IntegerVal 0,IntegerVal 2680,IntegerVal 32767],VectorVal [IntegerVal 0,IntegerVal (-32768),IntegerVal (-1),IntegerVal (-1)]],IndexVal 0], start_saturated = False}";
      int reported = 0;
      arg2.val[0] = vcreate_s16(UINT64_C(0x7fff7fff7fff8000));
      arg2.val[1] = vcreate_s16(UINT64_C(0x7fff0a780000ffff));
      arg2.val[2] = vcreate_s16(UINT64_C(0xffffffff80000000));
      clear_neon_saturated();
      vst3_lane_s16(result, arg2, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         int16_t got;
         int16_t exp;
         got = result[0];
         exp = -32768;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi16 " Got: %" PRIi16 "\n",
                      "   Elem 0 ",
                      exp,
                      got);
            }
      }
      {
         int16_t got;
         int16_t exp;
         got = result[1];
         exp = -1;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi16 " Got: %" PRIi16 "\n",
                      "   Elem 1 ",
                      exp,
                      got);
            }
      }
      {
         int16_t got;
         int16_t exp;
         got = result[2];
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi16 " Got: %" PRIi16 "\n",
                      "   Elem 2 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1705() {

{
   {
      int32x2x3_t arg2;
      int32_t result[3];
      char* str1 = "ReproInfo2 {semantics = \"store3_lane\", fnname = \"vst3_lane_s32\", rettype = \"__transfersize(3) int32_t *\", argtypes = \"[/* result holder */,int32x2x3_t,__constrange(0,1) int]\", vals = [PtrVal [],ArrayVal [VectorVal [IntegerVal 2147418112,IntegerVal 2147457737],VectorVal [IntegerVal 65535,IntegerVal 2147450880],VectorVal [IntegerVal (-32768),IntegerVal (-2147418113)]],IndexVal 0], start_saturated = False}";
      int reported = 0;
      arg2.val[0] = vcreate_s32(UINT64_C(0x7fff9ac97fff0000));
      arg2.val[1] = vcreate_s32(UINT64_C(0x7fff80000000ffff));
      arg2.val[2] = vcreate_s32(UINT64_C(0x8000ffffffff8000));
      clear_neon_saturated();
      vst3_lane_s32(result, arg2, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         int32_t got;
         int32_t exp;
         got = result[0];
         exp = 2147418112;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi32 " Got: %" PRIi32 "\n",
                      "   Elem 0 ",
                      exp,
                      got);
            }
      }
      {
         int32_t got;
         int32_t exp;
         got = result[1];
         exp = 65535;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi32 " Got: %" PRIi32 "\n",
                      "   Elem 1 ",
                      exp,
                      got);
            }
      }
      {
         int32_t got;
         int32_t exp;
         got = result[2];
         exp = -32768;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi32 " Got: %" PRIi32 "\n",
                      "   Elem 2 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1706() {

{
   {
      float32x2x3_t arg2;
      float32_t result[3];
      char* str1 = "ReproInfo2 {semantics = \"store3_lane\", fnname = \"vst3_lane_f32\", rettype = \"__transfersize(3) float32_t *\", argtypes = \"[/* result holder */,float32x2x3_t,__constrange(0,1) int]\", vals = [PtrVal [],ArrayVal [VectorVal [FloatVal 0.9486326575279236,FloatVal 0.5187729597091675],VectorVal [FloatVal 0.7621473670005798,FloatVal 0.8201578855514526],VectorVal [FloatVal 0.8728932738304138,FloatVal 0.7380178570747375]],IndexVal 0], start_saturated = False}";
      int reported = 0;
      arg2.val[0] = vcreate_f32(UINT64_C(0x3f04ce4e3f72d997));
      arg2.val[1] = vcreate_f32(UINT64_C(0x3f51f5de3f431c17));
      arg2.val[2] = vcreate_f32(UINT64_C(0x3f3ceebd3f5f75ef));
      clear_neon_saturated();
      vst3_lane_f32(result, arg2, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = result[0];
         exp = ((float32_t) 0.9486326575279236);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 0 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = result[1];
         exp = ((float32_t) 0.7621473670005798);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 1 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = result[2];
         exp = ((float32_t) 0.8728932738304138);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 2 ", exp, got);
            }
      }
   }
}
}
void dotests_1707() {

{
   {
      float64x1x3_t arg2;
      float64_t result[3];
      char* str1 = "ReproInfo2 {semantics = \"store3_lane\", fnname = \"vst3_lane_f64\", rettype = \"__transfersize(3) float64_t *\", argtypes = \"[/* result holder */,float64x1x3_t,__constrange(0,0) int]\", vals = [PtrVal [],ArrayVal [VectorVal [FloatVal 0.7972128152385554],VectorVal [FloatVal 0.922536583351561],VectorVal [FloatVal 0.7368371141511636]],IndexVal 0], start_saturated = False}";
      int reported = 0;
      arg2.val[0] = vcreate_f64(UINT64_C(0x3fe982c4732cda9c));
      arg2.val[1] = vcreate_f64(UINT64_C(0x3fed856b70db7919));
      arg2.val[2] = vcreate_f64(UINT64_C(0x3fe7942b6d7843b8));
      clear_neon_saturated();
      vst3_lane_f64(result, arg2, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float64_t got;
         float64_t exp;
         got = result[0];
         exp = 0.7972128152385554;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 0 ", exp, got);
            }
      }
      {
         float64_t got;
         float64_t exp;
         got = result[1];
         exp = 0.922536583351561;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 1 ", exp, got);
            }
      }
      {
         float64_t got;
         float64_t exp;
         got = result[2];
         exp = 0.7368371141511636;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 2 ", exp, got);
            }
      }
   }
}
}
void dotests_1708() {

{
   {
      poly8x8x3_t arg2;
      poly8_t result[3];
      char* str1 = "ReproInfo2 {semantics = \"store3_lane\", fnname = \"vst3_lane_p8\", rettype = \"__transfersize(3) poly8_t *\", argtypes = \"[/* result holder */,poly8x8x3_t,__constrange(0,7) int]\", vals = [PtrVal [],ArrayVal [VectorVal [PolyVal [0,1,0,0,1,0,0,1],PolyVal [1,1,0,1,0,1,1,0],PolyVal [0,1,1,1,1,1,1,0],PolyVal [1,0,0,0,0,1,0,1],PolyVal [1,1,0,0,1,1,1,1],PolyVal [1,1,1,1,1,0,1,1],PolyVal [0,1,0,1,1,1,0,1],PolyVal [0,1,1,0,0,0,1,1]],VectorVal [PolyVal [1,1,0,0,0,0,1,1],PolyVal [0,0,1,0,0,1,0,1],PolyVal [0,0,1,1,1,0,0,1],PolyVal [1,0,1,0,1,1,1,0],PolyVal [1,1,1,0,1,1,1,0],PolyVal [0,1,1,1,1,0,0,1],PolyVal [1,0,1,0,0,0,0,0],PolyVal [0,0,1,0,1,0,0,0]],VectorVal [PolyVal [1,0,1,0,0,1,1,1],PolyVal [1,0,1,0,0,0,1,1],PolyVal [1,1,0,1,1,1,0,1],PolyVal [1,0,0,0,0,1,0,0],PolyVal [0,0,0,1,0,0,0,1],PolyVal [1,0,1,0,1,0,1,1],PolyVal [0,1,1,0,1,1,1,1],PolyVal [0,1,0,1,1,0,0,0]]],IndexVal 7], start_saturated = False}";
      int reported = 0;
      arg2.val[0] = vcreate_p8(UINT64_C(0xc6badff3a17e6b92));
      arg2.val[1] = vcreate_p8(UINT64_C(0x14059e77759ca4c3));
      arg2.val[2] = vcreate_p8(UINT64_C(0x1af6d58821bbc5e5));
      clear_neon_saturated();
      vst3_lane_p8(result, arg2, 7);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         poly8_t got;
         poly8_t exp;
         got = result[0];
         exp = 198;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 0 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[1];
         exp = 20;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 1 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[2];
         exp = 26;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 2 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1709() {

{
   {
      poly16x4x3_t arg2;
      poly16_t result[3];
      char* str1 = "ReproInfo2 {semantics = \"store3_lane\", fnname = \"vst3_lane_p16\", rettype = \"__transfersize(3) poly16_t *\", argtypes = \"[/* result holder */,poly16x4x3_t,__constrange(0,3) int]\", vals = [PtrVal [],ArrayVal [VectorVal [PolyVal [1,0,0,1,0,1,0,1,1,1,0,0,0,0,0,0],PolyVal [0,1,0,1,0,0,0,0,0,0,0,0,0,1,1,0],PolyVal [1,1,0,0,1,0,1,0,1,1,1,0,0,1,1,1],PolyVal [1,0,0,0,1,1,1,1,1,1,1,1,0,1,0,0]],VectorVal [PolyVal [0,0,1,0,1,0,1,0,1,1,0,1,1,1,1,1],PolyVal [0,0,1,1,1,0,0,1,0,0,1,1,1,0,0,0],PolyVal [1,1,1,1,1,1,1,0,0,1,1,1,1,0,0,1],PolyVal [1,0,0,0,0,0,1,0,1,1,1,0,0,0,0,0]],VectorVal [PolyVal [0,0,0,0,1,0,1,1,0,1,1,0,0,0,0,1],PolyVal [0,1,0,1,0,0,0,0,0,1,0,1,1,0,0,1],PolyVal [0,1,0,0,0,0,1,1,1,0,1,1,1,0,0,1],PolyVal [1,0,0,1,0,1,1,1,1,0,1,1,0,1,0,0]]],IndexVal 0], start_saturated = False}";
      int reported = 0;
      arg2.val[0] = vcreate_p16(UINT64_C(0x2ff1e753600a03a9));
      arg2.val[1] = vcreate_p16(UINT64_C(0x07419e7f1c9cfb54));
      arg2.val[2] = vcreate_p16(UINT64_C(0x2de99dc29a0a86d0));
      clear_neon_saturated();
      vst3_lane_p16(result, arg2, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         poly16_t got;
         poly16_t exp;
         got = result[0];
         exp = 937;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 0 ",
                      exp,
                      got);
            }
      }
      {
         poly16_t got;
         poly16_t exp;
         got = result[1];
         exp = 64340;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 1 ",
                      exp,
                      got);
            }
      }
      {
         poly16_t got;
         poly16_t exp;
         got = result[2];
         exp = 34512;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 2 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1710() {
#if __ARM_NEON_FP16_INTRINSICS

{
   {
      float16x4x3_t arg2;
      __fp16 result[3];
      char* str1 = "ReproInfo2 {semantics = \"store3_lane\", fnname = \"vst3_lane_f16\", rettype = \"__transfersize(3) __fp16 *\", argtypes = \"[/* result holder */,float16x4x3_t,__constrange(0,3) int]\", vals = [PtrVal [],ArrayVal [VectorVal [FloatVal 8.515009198257236,FloatVal (-2.1567326855142017),FloatVal (-8.609124961921207),FloatVal 1.2874728431743154],VectorVal [FloatVal 0.11461172138802311,FloatVal (-7.078901731292692),FloatVal 7.98173036177122,FloatVal (-3.597437843588118)],VectorVal [FloatVal 3.458125607662449,FloatVal 8.574779839145346,FloatVal (-8.372830971084714),FloatVal (-4.00890692776996)]],IndexVal 1], start_saturated = False}";
      int reported = 0;
      arg2.val[0] = vcreate_f16(UINT64_C(0x3d26c84dc0504841));
      arg2.val[1] = vcreate_f16(UINT64_C(0xc33147fbc7142f55));
      arg2.val[2] = vcreate_f16(UINT64_C(0xc402c82f484942ea));
      clear_neon_saturated();
      vst3_lane_f16(result, arg2, 1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         __fp16 got;
         __fp16 exp;
         got = result[0];
         exp = -2.1567326855142017;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 0 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = result[1];
         exp = -7.078901731292692;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 1 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = result[2];
         exp = 8.574779839145346;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 2 ", exp, got);
            }
      }
   }
}
#endif
}
void dotests_1711() {

{
   {
      uint64x1x3_t arg2;
      uint64_t result[3];
      char* str1 = "ReproInfo2 {semantics = \"store3_lane\", fnname = \"vst3_lane_u64\", rettype = \"__transfersize(3) uint64_t *\", argtypes = \"[/* result holder */,uint64x1x3_t,__constrange(0,0) int]\", vals = [PtrVal [],ArrayVal [VectorVal [IntegerVal 281472829194240],VectorVal [IntegerVal 182398671192063],VectorVal [IntegerVal 9223512770048196607]],IndexVal 0], start_saturated = False}";
      int reported = 0;
      arg2.val[0] = vcreate_u64(UINT64_C(0x0000ffff7fff8000));
      arg2.val[1] = vcreate_u64(UINT64_C(0x0000a5e40000ffff));
      arg2.val[2] = vcreate_u64(UINT64_C(0x80007fff00007fff));
      clear_neon_saturated();
      vst3_lane_u64(result, arg2, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = result[0];
         exp = UINT64_C(0x0000ffff7fff8000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Elem 0 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = result[1];
         exp = UINT64_C(0x0000a5e40000ffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Elem 1 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = result[2];
         exp = UINT64_C(0x80007fff00007fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Elem 2 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1712() {

{
   {
      int64x1x3_t arg2;
      int64_t result[3];
      char* str1 = "ReproInfo2 {semantics = \"store3_lane\", fnname = \"vst3_lane_s64\", rettype = \"__transfersize(3) int64_t *\", argtypes = \"[/* result holder */,int64x1x3_t,__constrange(0,0) int]\", vals = [PtrVal [],ArrayVal [VectorVal [IntegerVal 1482106488297783296],VectorVal [IntegerVal 5615003572912488448],VectorVal [IntegerVal (-4101934833456939008)]],IndexVal 0], start_saturated = False}";
      int reported = 0;
      arg2.val[0] = vcreate_s64(UINT64_C(0x14917fffa24a8000));
      arg2.val[1] = vcreate_s64(UINT64_C(0x4dec7fffffff8000));
      arg2.val[2] = vcreate_s64(UINT64_C(0xc71300007fff8000));
      clear_neon_saturated();
      vst3_lane_s64(result, arg2, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         int64_t got;
         int64_t exp;
         got = result[0];
         exp = INT64_C(1482106488297783296);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi64 " Got: %" PRIi64 "\n",
                      "   Elem 0 ",
                      exp,
                      got);
            }
      }
      {
         int64_t got;
         int64_t exp;
         got = result[1];
         exp = INT64_C(5615003572912488448);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi64 " Got: %" PRIi64 "\n",
                      "   Elem 1 ",
                      exp,
                      got);
            }
      }
      {
         int64_t got;
         int64_t exp;
         got = result[2];
         exp = INT64_C(-4101934833456939008);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi64 " Got: %" PRIi64 "\n",
                      "   Elem 2 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1713() {

{
   {
      poly64x1x3_t arg2;
      poly64_t result[3];
      char* str1 = "ReproInfo2 {semantics = \"store3_lane\", fnname = \"vst3_lane_p64\", rettype = \"__transfersize(3) poly64_t *\", argtypes = \"[/* result holder */,poly64x1x3_t,__constrange(0,0) int]\", vals = [PtrVal [],ArrayVal [VectorVal [PolyVal [1,0,0,1,1,0,1,1,1,1,1,0,0,0,0,0,1,1,1,0,1,0,0,0,0,1,1,0,0,1,0,0,1,0,0,0,0,1,0,0,1,0,0,1,1,0,1,1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0]],VectorVal [PolyVal [1,1,1,0,1,1,1,0,1,1,1,1,0,0,1,1,0,0,0,0,1,0,1,0,1,0,1,0,0,1,0,0,1,0,1,1,1,0,0,1,0,0,0,0,1,0,0,1,0,1,1,0,1,1,0,0,0,0,1,0,1,0,1,1]],VectorVal [PolyVal [1,1,0,1,1,0,1,1,1,0,0,1,0,0,0,1,0,0,0,0,1,1,1,1,0,1,1,1,0,1,0,0,1,0,0,0,0,1,1,0,1,0,0,0,0,0,0,1,1,0,0,1,1,1,1,1,0,1,1,1,1,0,0,1]]],IndexVal 0], start_saturated = False}";
      int reported = 0;
      arg2.val[0] = vcreate_p64(UINT64_C(0x4140d921261707d9));
      arg2.val[1] = vcreate_p64(UINT64_C(0xd436909d2550cf77));
      arg2.val[2] = vcreate_p64(UINT64_C(0x9ef981612ef089db));
      clear_neon_saturated();
      vst3_lane_p64(result, arg2, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         poly64_t got;
         poly64_t exp;
         got = result[0];
         exp = 4701996747370989529;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu64 " Got: %" PRIu64 "\n",
                      "   Elem 0 ",
                      exp,
                      got);
            }
      }
      {
         poly64_t got;
         poly64_t exp;
         got = result[1];
         exp = -3155175484316135561;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu64 " Got: %" PRIu64 "\n",
                      "   Elem 1 ",
                      exp,
                      got);
            }
      }
      {
         poly64_t got;
         poly64_t exp;
         got = result[2];
         exp = -6991414692116657701;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu64 " Got: %" PRIu64 "\n",
                      "   Elem 2 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1714() {

{
   {
      uint8x16x4_t arg2;
      uint8_t result[4];
      char* str1 = "ReproInfo2 {semantics = \"store4_lane\", fnname = \"vst4q_lane_u8\", rettype = \"__transfersize(4) uint8_t *\", argtypes = \"[/* result holder */,uint8x16x4_t,__constrange(0,15) int]\", vals = [PtrVal [],ArrayVal [VectorVal [IntegerVal 127,IntegerVal 128,IntegerVal 0,IntegerVal 128,IntegerVal 127,IntegerVal 109,IntegerVal 127,IntegerVal 127,IntegerVal 0,IntegerVal 127,IntegerVal 127,IntegerVal 127,IntegerVal 128,IntegerVal 255,IntegerVal 0,IntegerVal 127],VectorVal [IntegerVal 255,IntegerVal 0,IntegerVal 128,IntegerVal 162,IntegerVal 117,IntegerVal 127,IntegerVal 0,IntegerVal 0,IntegerVal 128,IntegerVal 255,IntegerVal 70,IntegerVal 0,IntegerVal 12,IntegerVal 255,IntegerVal 0,IntegerVal 0],VectorVal [IntegerVal 128,IntegerVal 62,IntegerVal 138,IntegerVal 112,IntegerVal 127,IntegerVal 194,IntegerVal 255,IntegerVal 127,IntegerVal 127,IntegerVal 255,IntegerVal 255,IntegerVal 0,IntegerVal 127,IntegerVal 127,IntegerVal 0,IntegerVal 128],VectorVal [IntegerVal 255,IntegerVal 128,IntegerVal 127,IntegerVal 255,IntegerVal 255,IntegerVal 127,IntegerVal 255,IntegerVal 0,IntegerVal 255,IntegerVal 128,IntegerVal 255,IntegerVal 127,IntegerVal 127,IntegerVal 128,IntegerVal 255,IntegerVal 128]],IndexVal 15], start_saturated = False}";
      int reported = 0;
      arg2.val[0] = vcombine_u8(vcreate_u8(UINT64_C(0x7f7f6d7f8000807f)),
                                vcreate_u8(UINT64_C(0x7f00ff807f7f7f00)));
      arg2.val[1] = vcombine_u8(vcreate_u8(UINT64_C(0x00007f75a28000ff)),
                                vcreate_u8(UINT64_C(0x0000ff0c0046ff80)));
      arg2.val[2] = vcombine_u8(vcreate_u8(UINT64_C(0x7fffc27f708a3e80)),
                                vcreate_u8(UINT64_C(0x80007f7f00ffff7f)));
      arg2.val[3] = vcombine_u8(vcreate_u8(UINT64_C(0x00ff7fffff7f80ff)),
                                vcreate_u8(UINT64_C(0x80ff807f7fff80ff)));
      clear_neon_saturated();
      vst4q_lane_u8(result, arg2, 15);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint8_t got;
         uint8_t exp;
         got = result[0];
         exp = 127U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 0 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[1];
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 1 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[2];
         exp = 128U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 2 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[3];
         exp = 128U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 3 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1715() {

{
   {
      uint16x8x4_t arg2;
      uint16_t result[4];
      char* str1 = "ReproInfo2 {semantics = \"store4_lane\", fnname = \"vst4q_lane_u16\", rettype = \"__transfersize(4) uint16_t *\", argtypes = \"[/* result holder */,uint16x8x4_t,__constrange(0,7) int]\", vals = [PtrVal [],ArrayVal [VectorVal [IntegerVal 65535,IntegerVal 32767,IntegerVal 32767,IntegerVal 65535,IntegerVal 0,IntegerVal 42330,IntegerVal 32767,IntegerVal 0],VectorVal [IntegerVal 32767,IntegerVal 65535,IntegerVal 32768,IntegerVal 0,IntegerVal 50656,IntegerVal 0,IntegerVal 32767,IntegerVal 32767],VectorVal [IntegerVal 1102,IntegerVal 0,IntegerVal 0,IntegerVal 32768,IntegerVal 65535,IntegerVal 65535,IntegerVal 35904,IntegerVal 24953],VectorVal [IntegerVal 32768,IntegerVal 65535,IntegerVal 0,IntegerVal 32768,IntegerVal 32768,IntegerVal 32767,IntegerVal 32767,IntegerVal 65535]],IndexVal 7], start_saturated = False}";
      int reported = 0;
      arg2.val[0] = vcombine_u16(vcreate_u16(UINT64_C(0xffff7fff7fffffff)),
                                 vcreate_u16(UINT64_C(0x00007fffa55a0000)));
      arg2.val[1] = vcombine_u16(vcreate_u16(UINT64_C(0x00008000ffff7fff)),
                                 vcreate_u16(UINT64_C(0x7fff7fff0000c5e0)));
      arg2.val[2] = vcombine_u16(vcreate_u16(UINT64_C(0x800000000000044e)),
                                 vcreate_u16(UINT64_C(0x61798c40ffffffff)));
      arg2.val[3] = vcombine_u16(vcreate_u16(UINT64_C(0x80000000ffff8000)),
                                 vcreate_u16(UINT64_C(0xffff7fff7fff8000)));
      clear_neon_saturated();
      vst4q_lane_u16(result, arg2, 7);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint16_t got;
         uint16_t exp;
         got = result[0];
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 0 ",
                      exp,
                      got);
            }
      }
      {
         uint16_t got;
         uint16_t exp;
         got = result[1];
         exp = 32767U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 1 ",
                      exp,
                      got);
            }
      }
      {
         uint16_t got;
         uint16_t exp;
         got = result[2];
         exp = 24953U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 2 ",
                      exp,
                      got);
            }
      }
      {
         uint16_t got;
         uint16_t exp;
         got = result[3];
         exp = 65535U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 3 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1716() {

{
   {
      uint32x4x4_t arg2;
      uint32_t result[4];
      char* str1 = "ReproInfo2 {semantics = \"store4_lane\", fnname = \"vst4q_lane_u32\", rettype = \"__transfersize(4) uint32_t *\", argtypes = \"[/* result holder */,uint32x4x4_t,__constrange(0,3) int]\", vals = [PtrVal [],ArrayVal [VectorVal [IntegerVal 2147450880,IntegerVal 2147450880,IntegerVal 2148865107,IntegerVal 4294901760],VectorVal [IntegerVal 0,IntegerVal 2147450880,IntegerVal 32768,IntegerVal 2147418112],VectorVal [IntegerVal 1304297472,IntegerVal 65535,IntegerVal 4294967295,IntegerVal 4294967295],VectorVal [IntegerVal 2147549183,IntegerVal 2147418112,IntegerVal 2147483647,IntegerVal 2147418112]],IndexVal 3], start_saturated = True}";
      int reported = 0;
      arg2.val[0] = vcombine_u32(vcreate_u32(UINT64_C(0x7fff80007fff8000)),
                                 vcreate_u32(UINT64_C(0xffff000080151453)));
      arg2.val[1] = vcombine_u32(vcreate_u32(UINT64_C(0x7fff800000000000)),
                                 vcreate_u32(UINT64_C(0x7fff000000008000)));
      arg2.val[2] = vcombine_u32(vcreate_u32(UINT64_C(0x0000ffff4dbe0000)),
                                 vcreate_u32(UINT64_C(0xffffffffffffffff)));
      arg2.val[3] = vcombine_u32(vcreate_u32(UINT64_C(0x7fff00008000ffff)),
                                 vcreate_u32(UINT64_C(0x7fff00007fffffff)));
      set_neon_saturated();
      vst4q_lane_u32(result, arg2, 3);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      {
         uint32_t got;
         uint32_t exp;
         got = result[0];
         exp = 4294901760U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu32 " Got: %" PRIu32 "\n",
                      "   Elem 0 ",
                      exp,
                      got);
            }
      }
      {
         uint32_t got;
         uint32_t exp;
         got = result[1];
         exp = 2147418112U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu32 " Got: %" PRIu32 "\n",
                      "   Elem 1 ",
                      exp,
                      got);
            }
      }
      {
         uint32_t got;
         uint32_t exp;
         got = result[2];
         exp = 4294967295U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu32 " Got: %" PRIu32 "\n",
                      "   Elem 2 ",
                      exp,
                      got);
            }
      }
      {
         uint32_t got;
         uint32_t exp;
         got = result[3];
         exp = 2147418112U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu32 " Got: %" PRIu32 "\n",
                      "   Elem 3 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1717() {

{
   {
      int8x16x4_t arg2;
      int8_t result[4];
      char* str1 = "ReproInfo2 {semantics = \"store4_lane\", fnname = \"vst4q_lane_s8\", rettype = \"__transfersize(4) int8_t *\", argtypes = \"[/* result holder */,int8x16x4_t,__constrange(0,15) int]\", vals = [PtrVal [],ArrayVal [VectorVal [IntegerVal 0,IntegerVal 46,IntegerVal (-1),IntegerVal 127,IntegerVal 127,IntegerVal (-128),IntegerVal (-1),IntegerVal 127,IntegerVal (-1),IntegerVal (-128),IntegerVal (-1),IntegerVal (-1),IntegerVal (-46),IntegerVal 5,IntegerVal (-1),IntegerVal (-128)],VectorVal [IntegerVal 0,IntegerVal (-1),IntegerVal (-128),IntegerVal 0,IntegerVal 61,IntegerVal 91,IntegerVal (-1),IntegerVal 127,IntegerVal (-128),IntegerVal (-128),IntegerVal (-128),IntegerVal (-61),IntegerVal (-1),IntegerVal 127,IntegerVal 127,IntegerVal 127],VectorVal [IntegerVal 127,IntegerVal (-128),IntegerVal 127,IntegerVal 0,IntegerVal (-1),IntegerVal (-85),IntegerVal (-128),IntegerVal 0,IntegerVal (-40),IntegerVal (-88),IntegerVal 0,IntegerVal (-19),IntegerVal 73,IntegerVal (-121),IntegerVal (-15),IntegerVal 127],VectorVal [IntegerVal 0,IntegerVal 127,IntegerVal 127,IntegerVal 0,IntegerVal 0,IntegerVal (-1),IntegerVal (-2),IntegerVal 127,IntegerVal 14,IntegerVal (-128),IntegerVal (-1),IntegerVal (-128),IntegerVal 0,IntegerVal 0,IntegerVal 127,IntegerVal 127]],IndexVal 14], start_saturated = False}";
      int reported = 0;
      arg2.val[0] = vcombine_s8(vcreate_s8(UINT64_C(0x7fff807f7fff2e00)),
                                vcreate_s8(UINT64_C(0x80ff05d2ffff80ff)));
      arg2.val[1] = vcombine_s8(vcreate_s8(UINT64_C(0x7fff5b3d0080ff00)),
                                vcreate_s8(UINT64_C(0x7f7f7fffc3808080)));
      arg2.val[2] = vcombine_s8(vcreate_s8(UINT64_C(0x0080abff007f807f)),
                                vcreate_s8(UINT64_C(0x7ff18749ed00a8d8)));
      arg2.val[3] = vcombine_s8(vcreate_s8(UINT64_C(0x7ffeff00007f7f00)),
                                vcreate_s8(UINT64_C(0x7f7f000080ff800e)));
      clear_neon_saturated();
      vst4q_lane_s8(result, arg2, 14);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         int8_t got;
         int8_t exp;
         got = result[0];
         exp = -1;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 0 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[1];
         exp = 127;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 1 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[2];
         exp = -15;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 2 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[3];
         exp = 127;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 3 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1718() {

{
   {
      int16x8x4_t arg2;
      int16_t result[4];
      char* str1 = "ReproInfo2 {semantics = \"store4_lane\", fnname = \"vst4q_lane_s16\", rettype = \"__transfersize(4) int16_t *\", argtypes = \"[/* result holder */,int16x8x4_t,__constrange(0,7) int]\", vals = [PtrVal [],ArrayVal [VectorVal [IntegerVal 0,IntegerVal (-1),IntegerVal 22249,IntegerVal 0,IntegerVal 0,IntegerVal 32767,IntegerVal (-32768),IntegerVal 0],VectorVal [IntegerVal (-32768),IntegerVal 0,IntegerVal (-23115),IntegerVal 32767,IntegerVal (-32768),IntegerVal (-1),IntegerVal 24316,IntegerVal 32767],VectorVal [IntegerVal (-32768),IntegerVal (-32768),IntegerVal 0,IntegerVal (-32768),IntegerVal (-32768),IntegerVal (-1),IntegerVal 14394,IntegerVal 32767],VectorVal [IntegerVal 23232,IntegerVal 32767,IntegerVal (-32768),IntegerVal (-29283),IntegerVal (-1),IntegerVal (-1),IntegerVal 22286,IntegerVal 32767]],IndexVal 7], start_saturated = False}";
      int reported = 0;
      arg2.val[0] = vcombine_s16(vcreate_s16(UINT64_C(0x000056e9ffff0000)),
                                 vcreate_s16(UINT64_C(0x000080007fff0000)));
      arg2.val[1] = vcombine_s16(vcreate_s16(UINT64_C(0x7fffa5b500008000)),
                                 vcreate_s16(UINT64_C(0x7fff5efcffff8000)));
      arg2.val[2] = vcombine_s16(vcreate_s16(UINT64_C(0x8000000080008000)),
                                 vcreate_s16(UINT64_C(0x7fff383affff8000)));
      arg2.val[3] = vcombine_s16(vcreate_s16(UINT64_C(0x8d9d80007fff5ac0)),
                                 vcreate_s16(UINT64_C(0x7fff570effffffff)));
      clear_neon_saturated();
      vst4q_lane_s16(result, arg2, 7);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         int16_t got;
         int16_t exp;
         got = result[0];
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi16 " Got: %" PRIi16 "\n",
                      "   Elem 0 ",
                      exp,
                      got);
            }
      }
      {
         int16_t got;
         int16_t exp;
         got = result[1];
         exp = 32767;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi16 " Got: %" PRIi16 "\n",
                      "   Elem 1 ",
                      exp,
                      got);
            }
      }
      {
         int16_t got;
         int16_t exp;
         got = result[2];
         exp = 32767;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi16 " Got: %" PRIi16 "\n",
                      "   Elem 2 ",
                      exp,
                      got);
            }
      }
      {
         int16_t got;
         int16_t exp;
         got = result[3];
         exp = 32767;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi16 " Got: %" PRIi16 "\n",
                      "   Elem 3 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1719() {

{
   {
      int32x4x4_t arg2;
      int32_t result[4];
      char* str1 = "ReproInfo2 {semantics = \"store4_lane\", fnname = \"vst4q_lane_s32\", rettype = \"__transfersize(4) int32_t *\", argtypes = \"[/* result holder */,int32x4x4_t,__constrange(0,3) int]\", vals = [PtrVal [],ArrayVal [VectorVal [IntegerVal 1166432328,IntegerVal (-2147450881),IntegerVal 2147450880,IntegerVal (-2147450880)],VectorVal [IntegerVal 2147450880,IntegerVal 32767,IntegerVal (-785383425),IntegerVal 32767],VectorVal [IntegerVal 0,IntegerVal 2147483647,IntegerVal 2147450879,IntegerVal 32767],VectorVal [IntegerVal (-50311),IntegerVal (-2147459921),IntegerVal 2147450879,IntegerVal 32768]],IndexVal 2], start_saturated = False}";
      int reported = 0;
      arg2.val[0] = vcombine_s32(vcreate_s32(UINT64_C(0x80007fff45865848)),
                                 vcreate_s32(UINT64_C(0x800080007fff8000)));
      arg2.val[1] = vcombine_s32(vcreate_s32(UINT64_C(0x00007fff7fff8000)),
                                 vcreate_s32(UINT64_C(0x00007fffd12fffff)));
      arg2.val[2] = vcombine_s32(vcreate_s32(UINT64_C(0x7fffffff00000000)),
                                 vcreate_s32(UINT64_C(0x00007fff7fff7fff)));
      arg2.val[3] = vcombine_s32(vcreate_s32(UINT64_C(0x80005cafffff3b79)),
                                 vcreate_s32(UINT64_C(0x000080007fff7fff)));
      clear_neon_saturated();
      vst4q_lane_s32(result, arg2, 2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         int32_t got;
         int32_t exp;
         got = result[0];
         exp = 2147450880;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi32 " Got: %" PRIi32 "\n",
                      "   Elem 0 ",
                      exp,
                      got);
            }
      }
      {
         int32_t got;
         int32_t exp;
         got = result[1];
         exp = -785383425;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi32 " Got: %" PRIi32 "\n",
                      "   Elem 1 ",
                      exp,
                      got);
            }
      }
      {
         int32_t got;
         int32_t exp;
         got = result[2];
         exp = 2147450879;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi32 " Got: %" PRIi32 "\n",
                      "   Elem 2 ",
                      exp,
                      got);
            }
      }
      {
         int32_t got;
         int32_t exp;
         got = result[3];
         exp = 2147450879;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi32 " Got: %" PRIi32 "\n",
                      "   Elem 3 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1720() {

{
   {
      float32x4x4_t arg2;
      float32_t result[4];
      char* str1 = "ReproInfo2 {semantics = \"store4_lane\", fnname = \"vst4q_lane_f32\", rettype = \"__transfersize(4) float32_t *\", argtypes = \"[/* result holder */,float32x4x4_t,__constrange(0,3) int]\", vals = [PtrVal [],ArrayVal [VectorVal [FloatVal 0.5070829391479492,FloatVal 0.7648336887359619,FloatVal 0.8468017578125,FloatVal 0.2755023241043091],VectorVal [FloatVal 0.14427369832992554,FloatVal 2.869194746017456e-2,FloatVal 0.7545292377471924,FloatVal 0.1781623363494873],VectorVal [FloatVal 0.5601433515548706,FloatVal 0.8489700555801392,FloatVal 0.8714017271995544,FloatVal 0.9918408393859863],VectorVal [FloatVal 0.7695473432540894,FloatVal 0.590230405330658,FloatVal 0.8309130668640137,FloatVal 0.283352255821228]],IndexVal 2], start_saturated = False}";
      int reported = 0;
      arg2.val[0] = vcombine_f32(vcreate_f32(UINT64_C(0x3f43cc243f01d030)),
                                 vcreate_f32(UINT64_C(0x3e8d0ea43f58c800)));
      arg2.val[1] = vcombine_f32(vcreate_f32(UINT64_C(0x3ceb0b603e13bc7c)),
                                 vcreate_f32(UINT64_C(0x3e3670303f4128d4)));
      arg2.val[2] = vcombine_f32(vcreate_f32(UINT64_C(0x3f59561a3f0f658e)),
                                 vcreate_f32(UINT64_C(0x3f7de9483f5f142f)));
      arg2.val[3] = vcombine_f32(vcreate_f32(UINT64_C(0x3f1719573f45010e)),
                                 vcreate_f32(UINT64_C(0x3e91138c3f54b6b8)));
      clear_neon_saturated();
      vst4q_lane_f32(result, arg2, 2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = result[0];
         exp = ((float32_t) 0.8468017578125);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 0 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = result[1];
         exp = ((float32_t) 0.7545292377471924);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 1 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = result[2];
         exp = ((float32_t) 0.8714017271995544);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 2 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = result[3];
         exp = ((float32_t) 0.8309130668640137);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 3 ", exp, got);
            }
      }
   }
}
}
void dotests_1721() {

{
   {
      float64x2x4_t arg2;
      float64_t result[4];
      char* str1 = "ReproInfo2 {semantics = \"store4_lane\", fnname = \"vst4q_lane_f64\", rettype = \"__transfersize(4) float64_t *\", argtypes = \"[/* result holder */,float64x2x4_t,__constrange(0,1) int]\", vals = [PtrVal [],ArrayVal [VectorVal [FloatVal 0.32563542515426647,FloatVal 0.153258086154343],VectorVal [FloatVal 0.6410560683391079,FloatVal 0.5097715988085578],VectorVal [FloatVal 0.994672138194334,FloatVal 0.3436227221829289],VectorVal [FloatVal 0.561333698798839,FloatVal 0.34232038582282753]],IndexVal 1], start_saturated = False}";
      int reported = 0;
      arg2.val[0] = vcombine_f64(vcreate_f64(UINT64_C(0x3fd4d735f75d396e)),
                                 vcreate_f64(UINT64_C(0x3fc39df601f0b2b4)));
      arg2.val[1] = vcombine_f64(vcreate_f64(UINT64_C(0x3fe48388040d66e3)),
                                 vcreate_f64(UINT64_C(0x3fe0500c8729ff16)));
      arg2.val[2] = vcombine_f64(vcreate_f64(UINT64_C(0x3fefd45aa9f92f92)),
                                 vcreate_f64(UINT64_C(0x3fd5fdea287c0b08)));
      arg2.val[3] = vcombine_f64(vcreate_f64(UINT64_C(0x3fe1f67216cf7ab3)),
                                 vcreate_f64(UINT64_C(0x3fd5e893c3773dca)));
      clear_neon_saturated();
      vst4q_lane_f64(result, arg2, 1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float64_t got;
         float64_t exp;
         got = result[0];
         exp = 0.153258086154343;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 0 ", exp, got);
            }
      }
      {
         float64_t got;
         float64_t exp;
         got = result[1];
         exp = 0.5097715988085578;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 1 ", exp, got);
            }
      }
      {
         float64_t got;
         float64_t exp;
         got = result[2];
         exp = 0.3436227221829289;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 2 ", exp, got);
            }
      }
      {
         float64_t got;
         float64_t exp;
         got = result[3];
         exp = 0.34232038582282753;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 3 ", exp, got);
            }
      }
   }
}
}
void dotests_1722() {

{
   {
      poly8x16x4_t arg2;
      poly8_t result[4];
      char* str1 = "ReproInfo2 {semantics = \"store4_lane\", fnname = \"vst4q_lane_p8\", rettype = \"__transfersize(4) poly8_t *\", argtypes = \"[/* result holder */,poly8x16x4_t,__constrange(0,15) int]\", vals = [PtrVal [],ArrayVal [VectorVal [PolyVal [0,1,0,1,0,1,1,0],PolyVal [0,1,1,1,0,0,0,0],PolyVal [0,0,1,0,0,0,1,0],PolyVal [1,0,1,0,1,1,1,0],PolyVal [0,0,1,0,0,1,1,1],PolyVal [0,1,1,1,1,0,0,0],PolyVal [1,1,0,1,1,1,1,1],PolyVal [1,1,1,0,0,1,0,0],PolyVal [0,1,0,1,1,0,1,0],PolyVal [1,0,1,0,1,1,1,0],PolyVal [1,0,0,1,0,1,0,0],PolyVal [0,1,1,0,0,1,0,1],PolyVal [1,1,0,1,1,1,1,0],PolyVal [0,1,0,0,0,1,1,1],PolyVal [1,0,1,1,1,1,1,0],PolyVal [1,1,0,0,0,0,0,0]],VectorVal [PolyVal [0,0,1,1,0,0,1,0],PolyVal [1,1,1,1,1,1,0,0],PolyVal [1,1,1,1,0,0,1,0],PolyVal [0,0,0,1,0,1,1,1],PolyVal [1,0,1,0,0,1,0,0],PolyVal [0,1,1,1,1,0,1,0],PolyVal [1,0,1,0,0,1,0,1],PolyVal [0,0,1,1,0,1,1,1],PolyVal [1,0,1,1,0,1,1,1],PolyVal [0,1,1,0,1,1,1,1],PolyVal [1,0,0,1,1,0,1,0],PolyVal [0,0,1,0,1,1,1,1],PolyVal [0,0,0,0,1,0,1,1],PolyVal [0,0,1,0,1,1,0,0],PolyVal [1,1,1,0,1,0,1,1],PolyVal [0,1,0,1,1,1,1,0]],VectorVal [PolyVal [0,1,0,1,0,0,0,1],PolyVal [1,1,0,1,0,0,0,1],PolyVal [1,0,1,1,0,0,1,0],PolyVal [1,1,1,1,0,0,1,0],PolyVal [0,1,0,0,1,1,1,0],PolyVal [0,1,0,0,0,1,1,0],PolyVal [0,1,1,1,0,0,1,0],PolyVal [0,1,0,0,0,0,1,0],PolyVal [0,1,1,1,1,0,1,0],PolyVal [1,0,1,0,1,0,1,0],PolyVal [1,0,1,0,1,0,1,1],PolyVal [1,1,1,0,0,1,1,1],PolyVal [1,1,1,1,0,1,0,0],PolyVal [0,1,0,0,1,1,1,0],PolyVal [1,1,1,1,0,0,0,1],PolyVal [1,1,1,1,1,1,0,1]],VectorVal [PolyVal [1,1,1,1,0,0,1,1],PolyVal [1,1,1,1,1,0,0,0],PolyVal [1,0,0,0,0,1,0,0],PolyVal [0,0,1,0,1,1,0,0],PolyVal [1,1,0,1,0,1,1,1],PolyVal [1,1,0,1,1,0,1,0],PolyVal [0,0,1,0,0,0,0,0],PolyVal [1,1,1,1,1,1,0,0],PolyVal [1,1,1,0,0,0,0,0],PolyVal [0,0,0,0,0,0,1,1],PolyVal [1,0,1,0,0,1,0,0],PolyVal [0,0,0,1,0,0,1,0],PolyVal [1,1,1,0,1,1,1,1],PolyVal [0,0,0,1,1,1,1,0],PolyVal [1,1,0,1,1,0,1,1],PolyVal [0,1,0,1,0,0,1,0]]],IndexVal 2], start_saturated = False}";
      int reported = 0;
      arg2.val[0] = vcombine_p8(vcreate_p8(UINT64_C(0x27fb1ee475440e6a)),
                                vcreate_p8(UINT64_C(0x037de27ba629755a)));
      arg2.val[1] = vcombine_p8(vcreate_p8(UINT64_C(0xeca55e25e84f3f4c)),
                                vcreate_p8(UINT64_C(0x7ad734d0f459f6ed)));
      arg2.val[2] = vcombine_p8(vcreate_p8(UINT64_C(0x424e62724f4d8b8a)),
                                vcreate_p8(UINT64_C(0xbf8f722fe7d5555e)));
      arg2.val[3] = vcombine_p8(vcreate_p8(UINT64_C(0x3f045beb34211fcf)),
                                vcreate_p8(UINT64_C(0x4adb78f74825c007)));
      clear_neon_saturated();
      vst4q_lane_p8(result, arg2, 2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         poly8_t got;
         poly8_t exp;
         got = result[0];
         exp = 68;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 0 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[1];
         exp = 79;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 1 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[2];
         exp = 77;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 2 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[3];
         exp = 33;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 3 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1723() {

{
   {
      poly16x8x4_t arg2;
      poly16_t result[4];
      char* str1 = "ReproInfo2 {semantics = \"store4_lane\", fnname = \"vst4q_lane_p16\", rettype = \"__transfersize(4) poly16_t *\", argtypes = \"[/* result holder */,poly16x8x4_t,__constrange(0,7) int]\", vals = [PtrVal [],ArrayVal [VectorVal [PolyVal [0,1,1,0,1,0,1,1,1,0,0,1,0,1,1,1],PolyVal [0,0,0,0,1,0,0,0,1,1,1,0,1,0,0,1],PolyVal [1,0,0,0,1,1,1,0,0,1,0,0,0,0,1,1],PolyVal [1,1,0,1,1,1,0,0,0,1,1,0,1,1,0,0],PolyVal [1,1,0,0,0,1,0,0,1,0,1,0,1,1,0,1],PolyVal [0,0,1,1,0,1,0,1,1,1,1,1,1,1,0,1],PolyVal [0,0,0,0,1,0,1,1,0,0,0,1,0,0,0,1],PolyVal [0,1,0,0,1,0,1,0,0,1,1,1,1,0,0,1]],VectorVal [PolyVal [1,1,0,1,0,1,0,1,1,0,1,1,1,1,1,1],PolyVal [1,0,0,0,0,0,1,1,0,1,0,0,1,0,1,1],PolyVal [0,0,0,0,1,1,0,1,0,1,0,0,1,1,0,1],PolyVal [0,1,1,0,1,0,1,1,1,0,1,0,1,1,0,1],PolyVal [1,0,1,0,1,0,0,1,0,1,1,0,1,1,1,0],PolyVal [1,1,1,0,0,0,0,0,1,1,0,1,0,1,1,0],PolyVal [0,1,0,1,1,1,1,1,0,0,1,0,0,0,1,1],PolyVal [0,0,1,1,1,0,0,1,0,1,1,1,1,1,1,1]],VectorVal [PolyVal [0,1,0,1,1,0,1,1,1,0,1,0,0,0,1,1],PolyVal [0,0,1,0,0,1,0,0,0,1,1,1,0,1,0,0],PolyVal [0,1,1,0,1,0,0,1,1,1,1,0,0,1,1,0],PolyVal [1,0,1,0,1,0,0,0,0,0,1,1,1,1,1,1],PolyVal [1,0,0,0,1,1,0,1,1,0,0,1,0,1,0,1],PolyVal [1,1,1,0,0,0,0,0,0,0,1,0,0,1,0,1],PolyVal [1,0,1,1,1,0,0,0,1,0,0,0,1,1,1,1],PolyVal [0,0,0,0,0,1,0,0,1,0,1,1,1,0,1,1]],VectorVal [PolyVal [0,0,1,0,0,1,1,0,0,0,0,0,0,0,0,1],PolyVal [1,1,1,0,0,1,1,0,0,0,1,0,1,1,0,0],PolyVal [0,0,1,1,0,1,1,1,1,1,1,0,1,0,1,1],PolyVal [1,0,0,1,1,0,0,0,1,0,1,1,1,1,1,1],PolyVal [1,1,1,1,1,0,0,1,0,0,1,1,1,1,0,0],PolyVal [1,0,1,0,1,1,1,0,1,1,0,0,1,0,0,0],PolyVal [0,1,1,0,1,0,1,0,0,1,0,0,0,1,0,0],PolyVal [0,0,0,1,1,0,1,1,0,1,1,0,0,1,0,0]]],IndexVal 3], start_saturated = False}";
      int reported = 0;
      arg2.val[0] = vcombine_p16(vcreate_p16(UINT64_C(0x363bc2719710e9d6)),
                                 vcreate_p16(UINT64_C(0x9e5288d0bfacb523)));
      arg2.val[1] = vcombine_p16(vcreate_p16(UINT64_C(0xb5d6b2b0d2c1fdab)),
                                 vcreate_p16(UINT64_C(0xfe9cc4fa6b077695)));
      arg2.val[2] = vcombine_p16(vcreate_p16(UINT64_C(0xfc1567962e24c5da)),
                                 vcreate_p16(UINT64_C(0xdd20f11da407a9b1)));
      arg2.val[3] = vcombine_p16(vcreate_p16(UINT64_C(0xfd19d7ec34678064)),
                                 vcreate_p16(UINT64_C(0x26d8225613753c9f)));
      clear_neon_saturated();
      vst4q_lane_p16(result, arg2, 3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         poly16_t got;
         poly16_t exp;
         got = result[0];
         exp = 13883;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 0 ",
                      exp,
                      got);
            }
      }
      {
         poly16_t got;
         poly16_t exp;
         got = result[1];
         exp = 46550;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 1 ",
                      exp,
                      got);
            }
      }
      {
         poly16_t got;
         poly16_t exp;
         got = result[2];
         exp = 64533;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 2 ",
                      exp,
                      got);
            }
      }
      {
         poly16_t got;
         poly16_t exp;
         got = result[3];
         exp = 64793;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 3 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1724() {
#if __ARM_NEON_FP16_INTRINSICS

{
   {
      float16x8x4_t arg2;
      __fp16 result[4];
      char* str1 = "ReproInfo2 {semantics = \"store4_lane\", fnname = \"vst4q_lane_f16\", rettype = \"__transfersize(4) __fp16 *\", argtypes = \"[/* result holder */,float16x8x4_t,__constrange(0,7) int]\", vals = [PtrVal [],ArrayVal [VectorVal [FloatVal (-5.905716009044271),FloatVal 4.3387495559526705,FloatVal (-1.8558907064006487),FloatVal 7.829335243593569,FloatVal (-9.237155044291283),FloatVal 0.9603194344896053,FloatVal 4.750479410520613,FloatVal (-6.076713844970558)],VectorVal [FloatVal 9.96963474425548,FloatVal (-1.8735748550907907),FloatVal (-7.383560571678123),FloatVal (-7.236512388563905),FloatVal (-7.888066618257),FloatVal 9.883167629197615,FloatVal (-0.6147929444775606),FloatVal (-7.144069548517271)],VectorVal [FloatVal 5.343722697225584,FloatVal (-7.921956701235596),FloatVal (-8.423587698210325),FloatVal 4.522109672276141,FloatVal (-3.137885512023497),FloatVal 1.2429813470403932,FloatVal (-7.838282146652153),FloatVal 6.409325251962819],VectorVal [FloatVal 3.316294120026237,FloatVal (-6.345166128932325),FloatVal 6.5787075130975055,FloatVal 2.46700847034845,FloatVal (-5.105734308432841),FloatVal (-6.999676051333335),FloatVal (-4.699265365863104),FloatVal (-0.9263337038709984)]],IndexVal 5], start_saturated = False}";
      int reported = 0;
      arg2.val[0] = vcombine_f16(vcreate_f16(UINT64_C(0x47d4bf6c4456c5e7)),
                                 vcreate_f16(UINT64_C(0xc61344c03baec89e)));
      arg2.val[1] = vcombine_f16(vcreate_f16(UINT64_C(0xc73cc762bf7e48fc)),
                                 vcreate_f16(UINT64_C(0xc724b8eb48f1c7e3)));
      arg2.val[2] = vcombine_f16(vcreate_f16(UINT64_C(0x4485c836c7ec4557)),
                                 vcreate_f16(UINT64_C(0x4668c7d63cf8c246)));
      arg2.val[3] = vcombine_f16(vcreate_f16(UINT64_C(0x40ef4694c65842a1)),
                                 vcreate_f16(UINT64_C(0xbb69c4b3c6ffc51b)));
      clear_neon_saturated();
      vst4q_lane_f16(result, arg2, 5);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         __fp16 got;
         __fp16 exp;
         got = result[0];
         exp = 0.9603194344896053;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 0 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = result[1];
         exp = 9.883167629197615;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 1 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = result[2];
         exp = 1.2429813470403932;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 2 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = result[3];
         exp = -6.999676051333335;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 3 ", exp, got);
            }
      }
   }
}
#endif
}
void dotests_1725() {

{
   {
      uint64x2x4_t arg2;
      uint64_t result[4];
      char* str1 = "ReproInfo2 {semantics = \"store4_lane\", fnname = \"vst4q_lane_u64\", rettype = \"__transfersize(4) uint64_t *\", argtypes = \"[/* result holder */,uint64x2x4_t,__constrange(0,1) int]\", vals = [PtrVal [],ArrayVal [VectorVal [IntegerVal 18446462598732906495,IntegerVal 18446743678766381991],VectorVal [IntegerVal 16289800266318807040,IntegerVal 281470681776128],VectorVal [IntegerVal 9223505966819934208,IntegerVal 23796266346695],VectorVal [IntegerVal 10563192921702543330,IntegerVal 2443765752096849920]],IndexVal 1], start_saturated = False}";
      int reported = 0;
      arg2.val[0] = vcombine_u64(vcreate_u64(UINT64_C(0xffff00000000ffff)),
                                 vcreate_u64(UINT64_C(0xffffffa40b8d7ba7)));
      arg2.val[1] = vcombine_u64(vcreate_u64(UINT64_C(0xe210ff08ffff0000)),
                                 vcreate_u64(UINT64_C(0x0000ffff00008000)));
      arg2.val[2] = vcombine_u64(vcreate_u64(UINT64_C(0x800079ceffff8000)),
                                 vcreate_u64(UINT64_C(0x000015a48000a8c7)));
      arg2.val[3] = vcombine_u64(vcreate_u64(UINT64_C(0x9297ffff00002fe2)),
                                 vcreate_u64(UINT64_C(0x21ea0000ffff8000)));
      clear_neon_saturated();
      vst4q_lane_u64(result, arg2, 1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = result[0];
         exp = UINT64_C(0xffffffa40b8d7ba7);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Elem 0 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = result[1];
         exp = UINT64_C(0x0000ffff00008000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Elem 1 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = result[2];
         exp = UINT64_C(0x000015a48000a8c7);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Elem 2 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = result[3];
         exp = UINT64_C(0x21ea0000ffff8000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Elem 3 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1726() {

{
   {
      int64x2x4_t arg2;
      int64_t result[4];
      char* str1 = "ReproInfo2 {semantics = \"store4_lane\", fnname = \"vst4q_lane_s64\", rettype = \"__transfersize(4) int64_t *\", argtypes = \"[/* result holder */,int64x2x4_t,__constrange(0,1) int]\", vals = [PtrVal [],ArrayVal [VectorVal [IntegerVal 7102458089487515647,IntegerVal (-7075577224960999425)],VectorVal [IntegerVal (-6491798121071280129),IntegerVal (-281472829268177)],VectorVal [IntegerVal 9223090565261819904,IntegerVal 7219692415868370943],VectorVal [IntegerVal (-9223231299366453248),IntegerVal (-9223372032559841280)]],IndexVal 1], start_saturated = False}";
      int reported = 0;
      arg2.val[0] = vcombine_s64(vcreate_s64(UINT64_C(0x629100008000bfff)),
                                 vcreate_s64(UINT64_C(0x9dce80007d5affff)));
      arg2.val[1] = vcombine_s64(vcreate_s64(UINT64_C(0xa5e88000ffff7fff)),
                                 vcreate_s64(UINT64_C(0xffff00007fff5f2f)));
      arg2.val[2] = vcombine_s64(vcreate_s64(UINT64_C(0x7fff0000c9b00000)),
                                 vcreate_s64(UINT64_C(0x643180002b6a7fff)));
      arg2.val[3] = vcombine_s64(vcreate_s64(UINT64_C(0x80007fffffff8000)),
                                 vcreate_s64(UINT64_C(0x80000000ffff8000)));
      clear_neon_saturated();
      vst4q_lane_s64(result, arg2, 1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         int64_t got;
         int64_t exp;
         got = result[0];
         exp = INT64_C(-7075577224960999425);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi64 " Got: %" PRIi64 "\n",
                      "   Elem 0 ",
                      exp,
                      got);
            }
      }
      {
         int64_t got;
         int64_t exp;
         got = result[1];
         exp = INT64_C(-281472829268177);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi64 " Got: %" PRIi64 "\n",
                      "   Elem 1 ",
                      exp,
                      got);
            }
      }
      {
         int64_t got;
         int64_t exp;
         got = result[2];
         exp = INT64_C(7219692415868370943);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi64 " Got: %" PRIi64 "\n",
                      "   Elem 2 ",
                      exp,
                      got);
            }
      }
      {
         int64_t got;
         int64_t exp;
         got = result[3];
         exp = INT64_C(-9223372032559841280);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi64 " Got: %" PRIi64 "\n",
                      "   Elem 3 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1727() {

{
   {
      poly64x2x4_t arg2;
      poly64_t result[4];
      char* str1 = "ReproInfo2 {semantics = \"store4_lane\", fnname = \"vst4q_lane_p64\", rettype = \"__transfersize(4) poly64_t *\", argtypes = \"[/* result holder */,poly64x2x4_t,__constrange(0,1) int]\", vals = [PtrVal [],ArrayVal [VectorVal [PolyVal [1,1,0,1,0,1,0,1,1,1,1,1,0,1,1,0,1,0,1,0,0,0,1,1,1,0,0,1,0,0,0,1,1,1,1,0,1,0,0,1,0,0,0,0,1,0,0,1,0,0,1,1,0,0,1,1,1,1,1,1,0,0,0,1],PolyVal [1,1,1,1,1,1,0,0,1,0,0,1,0,1,1,0,1,1,0,1,1,1,0,1,1,0,0,0,0,1,0,1,0,0,0,0,1,1,1,0,0,1,0,1,1,0,0,0,1,0,1,1,1,1,1,0,1,0,0,0,1,1,1,1]],VectorVal [PolyVal [0,1,0,1,1,0,1,0,1,0,0,1,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,1,0,0,0,0,1,1,1,0,1,1,1,0,0,1,1,0,1,1,1,0,1,1,1,0],PolyVal [0,1,0,1,0,1,1,1,1,1,1,0,1,0,0,1,0,1,1,1,1,1,0,1,0,0,1,0,1,0,1,0,1,0,0,0,1,1,0,1,0,0,0,1,1,0,1,0,0,0,0,1,0,0,1,1,0,0,0,0,1,0,0,0]],VectorVal [PolyVal [0,1,0,0,1,1,0,0,1,0,0,1,1,0,0,1,1,0,0,0,1,0,0,0,0,0,1,0,1,1,1,1,1,0,0,1,0,0,0,1,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,1,1,1,1,0,0,1,1,0],PolyVal [1,0,0,1,1,0,1,1,0,1,1,1,0,0,0,0,1,0,1,0,1,0,0,0,1,0,1,1,0,1,0,0,1,0,1,1,1,1,0,0,1,0,1,1,1,0,1,1,0,0,0,0,1,1,0,1,0,1,0,0,0,0,0,1]],VectorVal [PolyVal [0,1,0,0,0,1,1,1,0,0,0,0,0,0,0,0,1,1,0,1,1,0,0,1,0,1,1,1,0,0,0,0,1,0,1,0,1,1,0,0,0,1,0,0,1,0,0,0,0,0,1,1,0,1,1,1,0,1,0,1,1,0,1,0],PolyVal [1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,1,1,0,0,0,1,1,1,0,1,1,0,1,1,0,0,1,0,0,0,1,0,0,1,1,0,1,1,0,0,1,0,0,0,1,0,1,1,0,0,1]]],IndexVal 0], start_saturated = False}";
      int reported = 0;
      arg2.val[0] = vcombine_p64(vcreate_p64(UINT64_C(0x8fcc909789c56fab)),
                                 vcreate_p64(UINT64_C(0xf17d1a70a1bb693f)));
      arg2.val[1] = vcombine_p64(vcreate_p64(UINT64_C(0x776770c8803c095a)),
                                 vcreate_p64(UINT64_C(0x10c858b154be97ea)));
      arg2.val[2] = vcombine_p64(vcreate_p64(UINT64_C(0x67860189f4119932)),
                                 vcreate_p64(UINT64_C(0x82b0dd3d2d150ed9)));
      arg2.val[3] = vcombine_p64(vcreate_p64(UINT64_C(0x5aec12350e9b00e2)),
                                 vcreate_p64(UINT64_C(0x9a26c89b71910249)));
      clear_neon_saturated();
      vst4q_lane_p64(result, arg2, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         poly64_t got;
         poly64_t exp;
         got = result[0];
         exp = -8084928250511003733;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu64 " Got: %" PRIu64 "\n",
                      "   Elem 0 ",
                      exp,
                      got);
            }
      }
      {
         poly64_t got;
         poly64_t exp;
         got = result[1];
         exp = 8603969619561810266;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu64 " Got: %" PRIu64 "\n",
                      "   Elem 1 ",
                      exp,
                      got);
            }
      }
      {
         poly64_t got;
         poly64_t exp;
         got = result[2];
         exp = 7459651524802746674;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu64 " Got: %" PRIu64 "\n",
                      "   Elem 2 ",
                      exp,
                      got);
            }
      }
      {
         poly64_t got;
         poly64_t exp;
         got = result[3];
         exp = 6551631577004835042;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu64 " Got: %" PRIu64 "\n",
                      "   Elem 3 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1728() {

{
   {
      uint8x8x4_t arg2;
      uint8_t result[4];
      char* str1 = "ReproInfo2 {semantics = \"store4_lane\", fnname = \"vst4_lane_u8\", rettype = \"__transfersize(4) uint8_t *\", argtypes = \"[/* result holder */,uint8x8x4_t,__constrange(0,7) int]\", vals = [PtrVal [],ArrayVal [VectorVal [IntegerVal 127,IntegerVal 0,IntegerVal 127,IntegerVal 0,IntegerVal 255,IntegerVal 127,IntegerVal 0,IntegerVal 229],VectorVal [IntegerVal 0,IntegerVal 13,IntegerVal 127,IntegerVal 92,IntegerVal 255,IntegerVal 127,IntegerVal 255,IntegerVal 128],VectorVal [IntegerVal 128,IntegerVal 255,IntegerVal 127,IntegerVal 127,IntegerVal 35,IntegerVal 127,IntegerVal 255,IntegerVal 0],VectorVal [IntegerVal 206,IntegerVal 128,IntegerVal 235,IntegerVal 0,IntegerVal 39,IntegerVal 0,IntegerVal 128,IntegerVal 0]],IndexVal 3], start_saturated = False}";
      int reported = 0;
      arg2.val[0] = vcreate_u8(UINT64_C(0xe5007fff007f007f));
      arg2.val[1] = vcreate_u8(UINT64_C(0x80ff7fff5c7f0d00));
      arg2.val[2] = vcreate_u8(UINT64_C(0x00ff7f237f7fff80));
      arg2.val[3] = vcreate_u8(UINT64_C(0x0080002700eb80ce));
      clear_neon_saturated();
      vst4_lane_u8(result, arg2, 3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint8_t got;
         uint8_t exp;
         got = result[0];
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 0 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[1];
         exp = 92U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 1 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[2];
         exp = 127U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 2 ",
                      exp,
                      got);
            }
      }
      {
         uint8_t got;
         uint8_t exp;
         got = result[3];
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 3 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1729() {

{
   {
      uint16x4x4_t arg2;
      uint16_t result[4];
      char* str1 = "ReproInfo2 {semantics = \"store4_lane\", fnname = \"vst4_lane_u16\", rettype = \"__transfersize(4) uint16_t *\", argtypes = \"[/* result holder */,uint16x4x4_t,__constrange(0,3) int]\", vals = [PtrVal [],ArrayVal [VectorVal [IntegerVal 65535,IntegerVal 32767,IntegerVal 0,IntegerVal 32768],VectorVal [IntegerVal 65535,IntegerVal 32768,IntegerVal 32767,IntegerVal 32768],VectorVal [IntegerVal 62757,IntegerVal 38256,IntegerVal 32768,IntegerVal 0],VectorVal [IntegerVal 65535,IntegerVal 65535,IntegerVal 32767,IntegerVal 0]],IndexVal 3], start_saturated = False}";
      int reported = 0;
      arg2.val[0] = vcreate_u16(UINT64_C(0x800000007fffffff));
      arg2.val[1] = vcreate_u16(UINT64_C(0x80007fff8000ffff));
      arg2.val[2] = vcreate_u16(UINT64_C(0x000080009570f525));
      arg2.val[3] = vcreate_u16(UINT64_C(0x00007fffffffffff));
      clear_neon_saturated();
      vst4_lane_u16(result, arg2, 3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint16_t got;
         uint16_t exp;
         got = result[0];
         exp = 32768U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 0 ",
                      exp,
                      got);
            }
      }
      {
         uint16_t got;
         uint16_t exp;
         got = result[1];
         exp = 32768U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 1 ",
                      exp,
                      got);
            }
      }
      {
         uint16_t got;
         uint16_t exp;
         got = result[2];
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 2 ",
                      exp,
                      got);
            }
      }
      {
         uint16_t got;
         uint16_t exp;
         got = result[3];
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 3 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1730() {

{
   {
      uint32x2x4_t arg2;
      uint32_t result[4];
      char* str1 = "ReproInfo2 {semantics = \"store4_lane\", fnname = \"vst4_lane_u32\", rettype = \"__transfersize(4) uint32_t *\", argtypes = \"[/* result holder */,uint32x2x4_t,__constrange(0,1) int]\", vals = [PtrVal [],ArrayVal [VectorVal [IntegerVal 2147516416,IntegerVal 4294967295],VectorVal [IntegerVal 4294901760,IntegerVal 2147523023],VectorVal [IntegerVal 65535,IntegerVal 2147549183],VectorVal [IntegerVal 2147549183,IntegerVal 2147450879]],IndexVal 0], start_saturated = False}";
      int reported = 0;
      arg2.val[0] = vcreate_u32(UINT64_C(0xffffffff80008000));
      arg2.val[1] = vcreate_u32(UINT64_C(0x800099cfffff0000));
      arg2.val[2] = vcreate_u32(UINT64_C(0x8000ffff0000ffff));
      arg2.val[3] = vcreate_u32(UINT64_C(0x7fff7fff8000ffff));
      clear_neon_saturated();
      vst4_lane_u32(result, arg2, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint32_t got;
         uint32_t exp;
         got = result[0];
         exp = 2147516416U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu32 " Got: %" PRIu32 "\n",
                      "   Elem 0 ",
                      exp,
                      got);
            }
      }
      {
         uint32_t got;
         uint32_t exp;
         got = result[1];
         exp = 4294901760U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu32 " Got: %" PRIu32 "\n",
                      "   Elem 1 ",
                      exp,
                      got);
            }
      }
      {
         uint32_t got;
         uint32_t exp;
         got = result[2];
         exp = 65535U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu32 " Got: %" PRIu32 "\n",
                      "   Elem 2 ",
                      exp,
                      got);
            }
      }
      {
         uint32_t got;
         uint32_t exp;
         got = result[3];
         exp = 2147549183U;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu32 " Got: %" PRIu32 "\n",
                      "   Elem 3 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1731() {

{
   {
      int8x8x4_t arg2;
      int8_t result[4];
      char* str1 = "ReproInfo2 {semantics = \"store4_lane\", fnname = \"vst4_lane_s8\", rettype = \"__transfersize(4) int8_t *\", argtypes = \"[/* result holder */,int8x8x4_t,__constrange(0,7) int]\", vals = [PtrVal [],ArrayVal [VectorVal [IntegerVal (-1),IntegerVal 0,IntegerVal 127,IntegerVal 34,IntegerVal (-84),IntegerVal 0,IntegerVal 127,IntegerVal 108],VectorVal [IntegerVal (-1),IntegerVal (-1),IntegerVal 127,IntegerVal (-1),IntegerVal (-128),IntegerVal 127,IntegerVal 127,IntegerVal (-128)],VectorVal [IntegerVal (-128),IntegerVal 127,IntegerVal 127,IntegerVal 0,IntegerVal (-1),IntegerVal (-1),IntegerVal (-1),IntegerVal 127],VectorVal [IntegerVal (-128),IntegerVal (-128),IntegerVal 127,IntegerVal 66,IntegerVal 0,IntegerVal (-128),IntegerVal (-1),IntegerVal (-1)]],IndexVal 7], start_saturated = False}";
      int reported = 0;
      arg2.val[0] = vcreate_s8(UINT64_C(0x6c7f00ac227f00ff));
      arg2.val[1] = vcreate_s8(UINT64_C(0x807f7f80ff7fffff));
      arg2.val[2] = vcreate_s8(UINT64_C(0x7fffffff007f7f80));
      arg2.val[3] = vcreate_s8(UINT64_C(0xffff8000427f8080));
      clear_neon_saturated();
      vst4_lane_s8(result, arg2, 7);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         int8_t got;
         int8_t exp;
         got = result[0];
         exp = 108;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 0 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[1];
         exp = -128;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 1 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[2];
         exp = 127;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 2 ",
                      exp,
                      got);
            }
      }
      {
         int8_t got;
         int8_t exp;
         got = result[3];
         exp = -1;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                      "   Elem 3 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1732() {

{
   {
      int16x4x4_t arg2;
      int16_t result[4];
      char* str1 = "ReproInfo2 {semantics = \"store4_lane\", fnname = \"vst4_lane_s16\", rettype = \"__transfersize(4) int16_t *\", argtypes = \"[/* result holder */,int16x4x4_t,__constrange(0,3) int]\", vals = [PtrVal [],ArrayVal [VectorVal [IntegerVal (-32768),IntegerVal 0,IntegerVal 8019,IntegerVal 7345],VectorVal [IntegerVal 22863,IntegerVal 24840,IntegerVal (-32768),IntegerVal (-722)],VectorVal [IntegerVal 32767,IntegerVal 32767,IntegerVal (-1),IntegerVal 32767],VectorVal [IntegerVal 14448,IntegerVal 16460,IntegerVal (-22918),IntegerVal 0]],IndexVal 2], start_saturated = False}";
      int reported = 0;
      arg2.val[0] = vcreate_s16(UINT64_C(0x1cb11f5300008000));
      arg2.val[1] = vcreate_s16(UINT64_C(0xfd2e80006108594f));
      arg2.val[2] = vcreate_s16(UINT64_C(0x7fffffff7fff7fff));
      arg2.val[3] = vcreate_s16(UINT64_C(0x0000a67a404c3870));
      clear_neon_saturated();
      vst4_lane_s16(result, arg2, 2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         int16_t got;
         int16_t exp;
         got = result[0];
         exp = 8019;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi16 " Got: %" PRIi16 "\n",
                      "   Elem 0 ",
                      exp,
                      got);
            }
      }
      {
         int16_t got;
         int16_t exp;
         got = result[1];
         exp = -32768;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi16 " Got: %" PRIi16 "\n",
                      "   Elem 1 ",
                      exp,
                      got);
            }
      }
      {
         int16_t got;
         int16_t exp;
         got = result[2];
         exp = -1;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi16 " Got: %" PRIi16 "\n",
                      "   Elem 2 ",
                      exp,
                      got);
            }
      }
      {
         int16_t got;
         int16_t exp;
         got = result[3];
         exp = -22918;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi16 " Got: %" PRIi16 "\n",
                      "   Elem 3 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1733() {

{
   {
      int32x2x4_t arg2;
      int32_t result[4];
      char* str1 = "ReproInfo2 {semantics = \"store4_lane\", fnname = \"vst4_lane_s32\", rettype = \"__transfersize(4) int32_t *\", argtypes = \"[/* result holder */,int32x2x4_t,__constrange(0,1) int]\", vals = [PtrVal [],ArrayVal [VectorVal [IntegerVal (-1472856064),IntegerVal (-1)],VectorVal [IntegerVal 2147450879,IntegerVal (-2147418113)],VectorVal [IntegerVal 49903,IntegerVal (-857276416)],VectorVal [IntegerVal (-2147418113),IntegerVal 2115403775]],IndexVal 0], start_saturated = False}";
      int reported = 0;
      arg2.val[0] = vcreate_s32(UINT64_C(0xffffffffa8360000));
      arg2.val[1] = vcreate_s32(UINT64_C(0x8000ffff7fff7fff));
      arg2.val[2] = vcreate_s32(UINT64_C(0xcce700000000c2ef));
      arg2.val[3] = vcreate_s32(UINT64_C(0x7e167fff8000ffff));
      clear_neon_saturated();
      vst4_lane_s32(result, arg2, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         int32_t got;
         int32_t exp;
         got = result[0];
         exp = -1472856064;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi32 " Got: %" PRIi32 "\n",
                      "   Elem 0 ",
                      exp,
                      got);
            }
      }
      {
         int32_t got;
         int32_t exp;
         got = result[1];
         exp = 2147450879;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi32 " Got: %" PRIi32 "\n",
                      "   Elem 1 ",
                      exp,
                      got);
            }
      }
      {
         int32_t got;
         int32_t exp;
         got = result[2];
         exp = 49903;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi32 " Got: %" PRIi32 "\n",
                      "   Elem 2 ",
                      exp,
                      got);
            }
      }
      {
         int32_t got;
         int32_t exp;
         got = result[3];
         exp = -2147418113;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi32 " Got: %" PRIi32 "\n",
                      "   Elem 3 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1734() {

{
   {
      float32x2x4_t arg2;
      float32_t result[4];
      char* str1 = "ReproInfo2 {semantics = \"store4_lane\", fnname = \"vst4_lane_f32\", rettype = \"__transfersize(4) float32_t *\", argtypes = \"[/* result holder */,float32x2x4_t,__constrange(0,1) int]\", vals = [PtrVal [],ArrayVal [VectorVal [FloatVal 0.8125426769256592,FloatVal 0.8664394021034241],VectorVal [FloatVal 0.8422385454177856,FloatVal 0.32597100734710693],VectorVal [FloatVal 0.9063645005226135,FloatVal 8.582484722137451e-2],VectorVal [FloatVal 0.1982467770576477,FloatVal 0.40963053703308105]],IndexVal 0], start_saturated = False}";
      int reported = 0;
      arg2.val[0] = vcreate_f32(UINT64_C(0x3f5dcef93f5002cc));
      arg2.val[1] = vcreate_f32(UINT64_C(0x3ea6e5ac3f579cf2));
      arg2.val[2] = vcreate_f32(UINT64_C(0x3dafc4f03f680781));
      arg2.val[3] = vcreate_f32(UINT64_C(0x3ed1bb183e4b0134));
      clear_neon_saturated();
      vst4_lane_f32(result, arg2, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = result[0];
         exp = ((float32_t) 0.8125426769256592);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 0 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = result[1];
         exp = ((float32_t) 0.8422385454177856);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 1 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = result[2];
         exp = ((float32_t) 0.9063645005226135);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 2 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = result[3];
         exp = ((float32_t) 0.1982467770576477);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 3 ", exp, got);
            }
      }
   }
}
}
void dotests_1735() {

{
   {
      float64x1x4_t arg2;
      float64_t result[4];
      char* str1 = "ReproInfo2 {semantics = \"store4_lane\", fnname = \"vst4_lane_f64\", rettype = \"__transfersize(4) float64_t *\", argtypes = \"[/* result holder */,float64x1x4_t,__constrange(0,0) int]\", vals = [PtrVal [],ArrayVal [VectorVal [FloatVal 0.11932719213870602],VectorVal [FloatVal 0.3859926192105134],VectorVal [FloatVal 0.11772367627592983],VectorVal [FloatVal 0.8140191046532428]],IndexVal 0], start_saturated = False}";
      int reported = 0;
      arg2.val[0] = vcreate_f64(UINT64_C(0x3fbe8c3a13c25e40));
      arg2.val[1] = vcreate_f64(UINT64_C(0x3fd8b41a63006b18));
      arg2.val[2] = vcreate_f64(UINT64_C(0x3fbe23238b91ec28));
      arg2.val[3] = vcreate_f64(UINT64_C(0x3fea0c71cb19c192));
      clear_neon_saturated();
      vst4_lane_f64(result, arg2, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float64_t got;
         float64_t exp;
         got = result[0];
         exp = 0.11932719213870602;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 0 ", exp, got);
            }
      }
      {
         float64_t got;
         float64_t exp;
         got = result[1];
         exp = 0.3859926192105134;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 1 ", exp, got);
            }
      }
      {
         float64_t got;
         float64_t exp;
         got = result[2];
         exp = 0.11772367627592983;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 2 ", exp, got);
            }
      }
      {
         float64_t got;
         float64_t exp;
         got = result[3];
         exp = 0.8140191046532428;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 3 ", exp, got);
            }
      }
   }
}
}
void dotests_1736() {

{
   {
      poly8x8x4_t arg2;
      poly8_t result[4];
      char* str1 = "ReproInfo2 {semantics = \"store4_lane\", fnname = \"vst4_lane_p8\", rettype = \"__transfersize(4) poly8_t *\", argtypes = \"[/* result holder */,poly8x8x4_t,__constrange(0,7) int]\", vals = [PtrVal [],ArrayVal [VectorVal [PolyVal [1,1,1,0,1,0,0,1],PolyVal [1,0,1,0,1,1,1,1],PolyVal [0,1,1,0,0,1,0,0],PolyVal [1,1,1,1,0,0,1,1],PolyVal [1,0,0,1,1,0,0,1],PolyVal [0,0,0,0,0,1,0,1],PolyVal [0,0,0,0,1,1,0,0],PolyVal [0,0,0,1,0,1,0,0]],VectorVal [PolyVal [1,1,1,0,0,1,1,1],PolyVal [1,0,0,1,0,1,0,0],PolyVal [0,0,0,1,0,1,0,1],PolyVal [1,0,1,1,0,1,1,1],PolyVal [1,0,1,1,0,1,1,0],PolyVal [1,1,0,0,1,0,0,0],PolyVal [1,0,0,0,0,1,1,0],PolyVal [1,0,1,1,1,1,1,1]],VectorVal [PolyVal [1,1,0,1,1,0,1,0],PolyVal [1,1,1,0,0,0,1,0],PolyVal [0,1,1,0,0,0,0,0],PolyVal [0,0,0,1,0,1,0,1],PolyVal [1,0,0,1,0,0,1,0],PolyVal [1,0,0,0,0,1,0,0],PolyVal [0,1,0,1,0,0,1,0],PolyVal [1,1,0,1,1,1,0,1]],VectorVal [PolyVal [1,1,1,1,0,1,1,1],PolyVal [1,1,1,1,0,1,0,1],PolyVal [0,1,1,1,1,1,1,0],PolyVal [0,1,0,1,0,0,0,1],PolyVal [1,1,0,1,1,0,0,0],PolyVal [0,0,0,0,0,0,1,0],PolyVal [0,1,0,0,1,0,1,0],PolyVal [1,0,0,0,0,0,1,1]]],IndexVal 7], start_saturated = False}";
      int reported = 0;
      arg2.val[0] = vcreate_p8(UINT64_C(0x2830a099cf26f597));
      arg2.val[1] = vcreate_p8(UINT64_C(0xfd61136deda829e7));
      arg2.val[2] = vcreate_p8(UINT64_C(0xbb4a2149a806475b));
      arg2.val[3] = vcreate_p8(UINT64_C(0xc152401b8a7eafef));
      clear_neon_saturated();
      vst4_lane_p8(result, arg2, 7);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         poly8_t got;
         poly8_t exp;
         got = result[0];
         exp = 40;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 0 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[1];
         exp = 253;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 1 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[2];
         exp = 187;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 2 ",
                      exp,
                      got);
            }
      }
      {
         poly8_t got;
         poly8_t exp;
         got = result[3];
         exp = 193;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                      "   Elem 3 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1737() {

{
   {
      poly16x4x4_t arg2;
      poly16_t result[4];
      char* str1 = "ReproInfo2 {semantics = \"store4_lane\", fnname = \"vst4_lane_p16\", rettype = \"__transfersize(4) poly16_t *\", argtypes = \"[/* result holder */,poly16x4x4_t,__constrange(0,3) int]\", vals = [PtrVal [],ArrayVal [VectorVal [PolyVal [1,1,0,0,1,0,0,0,1,1,1,0,1,1,0,1],PolyVal [1,1,1,1,1,0,1,0,0,0,0,1,1,1,0,1],PolyVal [0,0,0,0,1,1,0,1,1,0,1,1,0,1,0,0],PolyVal [1,0,1,1,0,0,1,1,0,1,1,0,0,1,1,1]],VectorVal [PolyVal [0,1,0,1,1,0,1,0,1,1,1,0,1,1,0,0],PolyVal [1,0,1,1,1,0,0,1,0,0,0,0,1,0,0,1],PolyVal [1,0,1,0,0,1,1,0,1,1,1,0,0,1,1,0],PolyVal [1,1,1,0,0,0,1,1,1,0,0,0,0,1,1,1]],VectorVal [PolyVal [0,0,1,0,0,0,1,1,0,0,0,1,0,1,1,0],PolyVal [0,0,1,0,1,0,1,1,1,0,0,0,0,1,0,0],PolyVal [1,1,0,0,0,0,1,1,0,1,1,1,1,0,0,0],PolyVal [0,1,0,1,1,0,1,0,1,0,1,1,1,0,1,1]],VectorVal [PolyVal [0,1,1,1,1,0,0,0,1,0,0,0,0,0,1,1],PolyVal [1,0,1,1,0,0,0,0,0,1,1,0,1,0,1,1],PolyVal [1,0,0,0,1,1,1,1,0,0,1,1,1,1,0,0],PolyVal [1,1,1,0,1,1,0,0,1,1,0,0,0,1,0,1]]],IndexVal 3], start_saturated = False}";
      int reported = 0;
      arg2.val[0] = vcreate_p16(UINT64_C(0xe6cd2db0b85fb713));
      arg2.val[1] = vcreate_p16(UINT64_C(0xe1c76765909d375a));
      arg2.val[2] = vcreate_p16(UINT64_C(0xdd5a1ec321d468c4));
      arg2.val[3] = vcreate_p16(UINT64_C(0xa3373cf1d60dc11e));
      clear_neon_saturated();
      vst4_lane_p16(result, arg2, 3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         poly16_t got;
         poly16_t exp;
         got = result[0];
         exp = 59085;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 0 ",
                      exp,
                      got);
            }
      }
      {
         poly16_t got;
         poly16_t exp;
         got = result[1];
         exp = 57799;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 1 ",
                      exp,
                      got);
            }
      }
      {
         poly16_t got;
         poly16_t exp;
         got = result[2];
         exp = 56666;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 2 ",
                      exp,
                      got);
            }
      }
      {
         poly16_t got;
         poly16_t exp;
         got = result[3];
         exp = 41783;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                      "   Elem 3 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1738() {
#if __ARM_NEON_FP16_INTRINSICS

{
   {
      float16x4x4_t arg2;
      __fp16 result[4];
      char* str1 = "ReproInfo2 {semantics = \"store4_lane\", fnname = \"vst4_lane_f16\", rettype = \"__transfersize(4) __fp16 *\", argtypes = \"[/* result holder */,float16x4x4_t,__constrange(0,3) int]\", vals = [PtrVal [],ArrayVal [VectorVal [FloatVal (-2.3651297363012747),FloatVal 5.461228708752753,FloatVal (-1.577282449822965),FloatVal 2.172440818575229],VectorVal [FloatVal (-9.131495241374342),FloatVal (-3.5353750539933237),FloatVal (-1.9066836821841697),FloatVal 0.456136274368399],VectorVal [FloatVal 7.201374532900363,FloatVal 5.898791481029599,FloatVal 2.7276550401072157,FloatVal (-8.231069543985203)],VectorVal [FloatVal (-2.4140730289131067),FloatVal (-0.7218589911138338),FloatVal 2.3838152375871466,FloatVal (-4.402054675338258)]],IndexVal 2], start_saturated = False}";
      int reported = 0;
      arg2.val[0] = vcreate_f16(UINT64_C(0x4058be4f4576c0ba));
      arg2.val[1] = vcreate_f16(UINT64_C(0x374cbfa0c312c890));
      arg2.val[2] = vcreate_f16(UINT64_C(0xc81d417445e64733));
      arg2.val[3] = vcreate_f16(UINT64_C(0xc46640c4b9c6c0d4));
      clear_neon_saturated();
      vst4_lane_f16(result, arg2, 2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         __fp16 got;
         __fp16 exp;
         got = result[0];
         exp = -1.577282449822965;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 0 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = result[1];
         exp = -1.9066836821841697;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 1 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = result[2];
         exp = 2.7276550401072157;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 2 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = result[3];
         exp = 2.3838152375871466;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Elem 3 ", exp, got);
            }
      }
   }
}
#endif
}
void dotests_1739() {

{
   {
      uint64x1x4_t arg2;
      uint64_t result[4];
      char* str1 = "ReproInfo2 {semantics = \"store4_lane\", fnname = \"vst4_lane_u64\", rettype = \"__transfersize(4) uint64_t *\", argtypes = \"[/* result holder */,uint64x1x4_t,__constrange(0,0) int]\", vals = [PtrVal [],ArrayVal [VectorVal [IntegerVal 7899454486043715309],VectorVal [IntegerVal 9223492025356117651],VectorVal [IntegerVal 9223512774343131136],VectorVal [IntegerVal 281472829259775]],IndexVal 0], start_saturated = False}";
      int reported = 0;
      arg2.val[0] = vcreate_u64(UINT64_C(0x6da08000800066ed));
      arg2.val[1] = vcreate_u64(UINT64_C(0x80006d20ffffe693));
      arg2.val[2] = vcreate_u64(UINT64_C(0x8000800000000000));
      arg2.val[3] = vcreate_u64(UINT64_C(0x0000ffff80007fff));
      clear_neon_saturated();
      vst4_lane_u64(result, arg2, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = result[0];
         exp = UINT64_C(0x6da08000800066ed);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Elem 0 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = result[1];
         exp = UINT64_C(0x80006d20ffffe693);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Elem 1 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = result[2];
         exp = UINT64_C(0x8000800000000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Elem 2 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = result[3];
         exp = UINT64_C(0x0000ffff80007fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Elem 3 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1740() {

{
   {
      int64x1x4_t arg2;
      int64_t result[4];
      char* str1 = "ReproInfo2 {semantics = \"store4_lane\", fnname = \"vst4_lane_s64\", rettype = \"__transfersize(4) int64_t *\", argtypes = \"[/* result holder */,int64x1x4_t,__constrange(0,0) int]\", vals = [PtrVal [],ArrayVal [VectorVal [IntegerVal 1982287519401607168],VectorVal [IntegerVal 893542309273042944],VectorVal [IntegerVal (-281472829194241)],VectorVal [IntegerVal 9223372034707304789]],IndexVal 0], start_saturated = False}";
      int reported = 0;
      arg2.val[0] = vcreate_s64(UINT64_C(0x1b827fff0c9f8000));
      arg2.val[1] = vcreate_s64(UINT64_C(0x0c667fff00008000));
      arg2.val[2] = vcreate_s64(UINT64_C(0xffff000080007fff));
      arg2.val[3] = vcreate_s64(UINT64_C(0x7fffffff80003155));
      clear_neon_saturated();
      vst4_lane_s64(result, arg2, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         int64_t got;
         int64_t exp;
         got = result[0];
         exp = INT64_C(1982287519401607168);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi64 " Got: %" PRIi64 "\n",
                      "   Elem 0 ",
                      exp,
                      got);
            }
      }
      {
         int64_t got;
         int64_t exp;
         got = result[1];
         exp = INT64_C(893542309273042944);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi64 " Got: %" PRIi64 "\n",
                      "   Elem 1 ",
                      exp,
                      got);
            }
      }
      {
         int64_t got;
         int64_t exp;
         got = result[2];
         exp = INT64_C(-281472829194241);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi64 " Got: %" PRIi64 "\n",
                      "   Elem 2 ",
                      exp,
                      got);
            }
      }
      {
         int64_t got;
         int64_t exp;
         got = result[3];
         exp = INT64_C(9223372034707304789);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIi64 " Got: %" PRIi64 "\n",
                      "   Elem 3 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1741() {

{
   {
      poly64x1x4_t arg2;
      poly64_t result[4];
      char* str1 = "ReproInfo2 {semantics = \"store4_lane\", fnname = \"vst4_lane_p64\", rettype = \"__transfersize(4) poly64_t *\", argtypes = \"[/* result holder */,poly64x1x4_t,__constrange(0,0) int]\", vals = [PtrVal [],ArrayVal [VectorVal [PolyVal [1,1,0,0,1,1,1,0,0,1,0,1,1,1,0,1,1,1,0,1,1,0,1,0,0,1,1,1,0,1,1,1,1,0,1,0,0,0,0,0,0,1,0,1,1,1,1,1,1,0,0,0,0,0,1,0,0,1,1,0,1,0,0,0]],VectorVal [PolyVal [0,0,1,0,0,0,1,0,0,1,0,0,1,1,0,1,1,1,0,0,1,1,1,0,0,1,0,0,1,0,0,1,0,0,1,1,1,0,0,0,0,1,1,0,1,0,0,0,0,0,1,0,0,1,0,1,1,0,0,1,1,0,0,0]],VectorVal [PolyVal [1,1,0,1,1,0,0,1,1,0,1,1,1,0,0,0,0,1,0,1,1,1,1,1,1,0,0,1,1,0,1,0,0,1,0,1,1,0,1,1,0,0,1,1,0,1,0,0,1,1,0,0,1,1,0,1,0,1,1,1,1,1,0,1]],VectorVal [PolyVal [0,1,1,1,1,1,0,1,0,0,1,0,0,0,0,1,0,1,1,0,1,0,1,0,1,1,1,1,0,1,0,1,0,0,0,1,0,1,0,1,1,0,0,1,0,0,0,0,1,0,0,0,1,0,1,1,0,0,0,1,1,1,0,0]]],IndexVal 0], start_saturated = False}";
      int reported = 0;
      arg2.val[0] = vcreate_p64(UINT64_C(0x1641fa05ee5bba73));
      arg2.val[1] = vcreate_p64(UINT64_C(0x19a4161c9273b244));
      arg2.val[2] = vcreate_p64(UINT64_C(0xbeb32cda59fa1d9b));
      arg2.val[3] = vcreate_p64(UINT64_C(0x38d109a8af5684be));
      clear_neon_saturated();
      vst4_lane_p64(result, arg2, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         poly64_t got;
         poly64_t exp;
         got = result[0];
         exp = 1603837845701376627;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu64 " Got: %" PRIu64 "\n",
                      "   Elem 0 ",
                      exp,
                      got);
            }
      }
      {
         poly64_t got;
         poly64_t exp;
         got = result[1];
         exp = 1847626059100697156;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu64 " Got: %" PRIu64 "\n",
                      "   Elem 1 ",
                      exp,
                      got);
            }
      }
      {
         poly64_t got;
         poly64_t exp;
         got = result[2];
         exp = -4705367869347979877;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu64 " Got: %" PRIu64 "\n",
                      "   Elem 2 ",
                      exp,
                      got);
            }
      }
      {
         poly64_t got;
         poly64_t exp;
         got = result[3];
         exp = 4094064156357330110;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %" PRIu64 " Got: %" PRIu64 "\n",
                      "   Elem 3 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1742() {

{
   {
      int8x8_t arg1;
      int8_t result;
      char* str1 = "ReproInfo2 {semantics = \"get_lane\", fnname = \"vget_lane_s8\", rettype = \"int8_t\", argtypes = \"[int8x8_t,__constrange(0,7) int]\", vals = [VectorVal [IntegerVal (-128),IntegerVal 127,IntegerVal 0,IntegerVal 25,IntegerVal (-128),IntegerVal 0,IntegerVal 127,IntegerVal 65],IndexVal 0], start_saturated = False}";
      int reported = 0;
      int8_t got;
      int8_t exp;
      arg1 = vcreate_s8(UINT64_C(0x417f008019007f80));
      clear_neon_saturated();
      //  Expect: "result" = 80
      result = vget_lane_s8(arg1, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = -128;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1743() {

{
   {
      int16x4_t arg1;
      int16_t result;
      char* str1 = "ReproInfo2 {semantics = \"get_lane\", fnname = \"vget_lane_s16\", rettype = \"int16_t\", argtypes = \"[int16x4_t,__constrange(0,3) int]\", vals = [VectorVal [IntegerVal (-2734),IntegerVal (-1),IntegerVal (-1),IntegerVal (-1)],IndexVal 2], start_saturated = False}";
      int reported = 0;
      int16_t got;
      int16_t exp;
      arg1 = vcreate_s16(UINT64_C(0xfffffffffffff552));
      clear_neon_saturated();
      //  Expect: "result" = ffff
      result = vget_lane_s16(arg1, 2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = -1;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIi16 " Got: %" PRIi16 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1744() {

{
   {
      int32x2_t arg1;
      int32_t result;
      char* str1 = "ReproInfo2 {semantics = \"get_lane\", fnname = \"vget_lane_s32\", rettype = \"int32_t\", argtypes = \"[int32x2_t,__constrange(0,1) int]\", vals = [VectorVal [IntegerVal (-2147450881),IntegerVal 757760000],IndexVal 1], start_saturated = False}";
      int reported = 0;
      int32_t got;
      int32_t exp;
      arg1 = vcreate_s32(UINT64_C(0x2d2a800080007fff));
      clear_neon_saturated();
      //  Expect: "result" = 2d2a8000
      result = vget_lane_s32(arg1, 1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = 757760000;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIi32 " Got: %" PRIi32 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1745() {

{
   {
      int8x16_t arg1;
      int8_t result;
      char* str1 = "ReproInfo2 {semantics = \"get_lane\", fnname = \"vgetq_lane_s8\", rettype = \"int8_t\", argtypes = \"[int8x16_t,__constrange(0,15) int]\", vals = [VectorVal [IntegerVal (-1),IntegerVal 127,IntegerVal (-1),IntegerVal (-128),IntegerVal (-18),IntegerVal (-128),IntegerVal (-128),IntegerVal 115,IntegerVal (-13),IntegerVal (-1),IntegerVal (-1),IntegerVal 127,IntegerVal (-128),IntegerVal 0,IntegerVal (-1),IntegerVal (-1)],IndexVal 15], start_saturated = False}";
      int reported = 0;
      int8_t got;
      int8_t exp;
      arg1 = vcombine_s8(vcreate_s8(UINT64_C(0x738080ee80ff7fff)),
                         vcreate_s8(UINT64_C(0xffff00807ffffff3)));
      clear_neon_saturated();
      //  Expect: "result" = ff
      result = vgetq_lane_s8(arg1, 15);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = -1;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1746() {

{
   {
      int16x8_t arg1;
      int16_t result;
      char* str1 = "ReproInfo2 {semantics = \"get_lane\", fnname = \"vgetq_lane_s16\", rettype = \"int16_t\", argtypes = \"[int16x8_t,__constrange(0,7) int]\", vals = [VectorVal [IntegerVal 32767,IntegerVal 0,IntegerVal 0,IntegerVal 0,IntegerVal 32767,IntegerVal (-32768),IntegerVal (-32768),IntegerVal (-32768)],IndexVal 4], start_saturated = False}";
      int reported = 0;
      int16_t got;
      int16_t exp;
      arg1 = vcombine_s16(vcreate_s16(UINT64_C(0x0000000000007fff)),
                          vcreate_s16(UINT64_C(0x8000800080007fff)));
      clear_neon_saturated();
      //  Expect: "result" = 7fff
      result = vgetq_lane_s16(arg1, 4);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = 32767;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIi16 " Got: %" PRIi16 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1747() {

{
   {
      int32x4_t arg1;
      int32_t result;
      char* str1 = "ReproInfo2 {semantics = \"get_lane\", fnname = \"vgetq_lane_s32\", rettype = \"int32_t\", argtypes = \"[int32x4_t,__constrange(0,3) int]\", vals = [VectorVal [IntegerVal (-40722),IntegerVal 32767,IntegerVal 2147450879,IntegerVal (-632127488)],IndexVal 3], start_saturated = False}";
      int reported = 0;
      int32_t got;
      int32_t exp;
      arg1 = vcombine_s32(vcreate_s32(UINT64_C(0x00007fffffff60ee)),
                          vcreate_s32(UINT64_C(0xda5280007fff7fff)));
      clear_neon_saturated();
      //  Expect: "result" = da528000
      result = vgetq_lane_s32(arg1, 3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = -632127488;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIi32 " Got: %" PRIi32 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1748() {

{
   {
      uint8x8_t arg1;
      uint8_t result;
      char* str1 = "ReproInfo2 {semantics = \"get_lane\", fnname = \"vget_lane_u8\", rettype = \"uint8_t\", argtypes = \"[uint8x8_t,__constrange(0,7) int]\", vals = [VectorVal [IntegerVal 155,IntegerVal 89,IntegerVal 255,IntegerVal 119,IntegerVal 0,IntegerVal 127,IntegerVal 167,IntegerVal 140],IndexVal 3], start_saturated = False}";
      int reported = 0;
      uint8_t got;
      uint8_t exp;
      arg1 = vcreate_u8(UINT64_C(0x8ca77f0077ff599b));
      clear_neon_saturated();
      //  Expect: "result" = 77
      result = vget_lane_u8(arg1, 3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = 119U;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1749() {

{
   {
      poly8x8_t arg1;
      poly8_t result;
      char* str1 = "ReproInfo2 {semantics = \"get_lane\", fnname = \"vget_lane_p8\", rettype = \"poly8_t\", argtypes = \"[poly8x8_t,__constrange(0,7) int]\", vals = [VectorVal [PolyVal [1,1,1,1,1,0,0,0],PolyVal [1,1,1,0,0,0,1,1],PolyVal [0,1,0,1,0,0,1,0],PolyVal [0,0,0,1,1,0,0,1],PolyVal [1,1,1,1,1,1,1,1],PolyVal [0,0,0,0,0,1,0,1],PolyVal [0,0,0,1,1,0,1,1],PolyVal [0,1,1,1,1,0,0,1]],IndexVal 5], start_saturated = False}";
      int reported = 0;
      poly8_t got;
      poly8_t exp;
      arg1 = vcreate_p8(UINT64_C(0x9ed8a0ff984ac71f));
      clear_neon_saturated();
      //  Expect: "result" = a0
      result = vget_lane_p8(arg1, 5);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = 160;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1750() {

{
   {
      uint16x4_t arg1;
      uint16_t result;
      char* str1 = "ReproInfo2 {semantics = \"get_lane\", fnname = \"vget_lane_u16\", rettype = \"uint16_t\", argtypes = \"[uint16x4_t,__constrange(0,3) int]\", vals = [VectorVal [IntegerVal 65535,IntegerVal 32768,IntegerVal 32768,IntegerVal 32768],IndexVal 0], start_saturated = False}";
      int reported = 0;
      uint16_t got;
      uint16_t exp;
      arg1 = vcreate_u16(UINT64_C(0x800080008000ffff));
      clear_neon_saturated();
      //  Expect: "result" = ffff
      result = vget_lane_u16(arg1, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = 65535U;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1751() {

{
   {
      poly16x4_t arg1;
      poly16_t result;
      char* str1 = "ReproInfo2 {semantics = \"get_lane\", fnname = \"vget_lane_p16\", rettype = \"poly16_t\", argtypes = \"[poly16x4_t,__constrange(0,3) int]\", vals = [VectorVal [PolyVal [1,1,1,0,0,0,0,1,1,1,0,1,1,1,0,1],PolyVal [1,1,1,1,0,0,1,0,1,0,0,0,1,0,1,1],PolyVal [0,1,0,1,0,1,1,0,1,1,0,1,0,0,0,1],PolyVal [1,1,1,1,0,0,1,0,1,0,1,0,0,0,0,1]],IndexVal 2], start_saturated = False}";
      int reported = 0;
      poly16_t got;
      poly16_t exp;
      arg1 = vcreate_p16(UINT64_C(0x854f8b6ad14fbb87));
      clear_neon_saturated();
      //  Expect: "result" = 8b6a
      result = vget_lane_p16(arg1, 2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = 35690;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1752() {

{
   {
      uint32x2_t arg1;
      uint32_t result;
      char* str1 = "ReproInfo2 {semantics = \"get_lane\", fnname = \"vget_lane_u32\", rettype = \"uint32_t\", argtypes = \"[uint32x2_t,__constrange(0,1) int]\", vals = [VectorVal [IntegerVal 4294934528,IntegerVal 2147450879],IndexVal 1], start_saturated = False}";
      int reported = 0;
      uint32_t got;
      uint32_t exp;
      arg1 = vcreate_u32(UINT64_C(0x7fff7fffffff8000));
      clear_neon_saturated();
      //  Expect: "result" = 7fff7fff
      result = vget_lane_u32(arg1, 1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = 2147450879U;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIu32 " Got: %" PRIu32 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1753() {

{
   {
      int64x1_t arg1;
      int64_t result;
      char* str1 = "ReproInfo2 {semantics = \"get_lane\", fnname = \"vget_lane_s64\", rettype = \"int64_t\", argtypes = \"[int64x1_t,__constrange(0,0) int]\", vals = [VectorVal [IntegerVal 9223090564025577283],IndexVal 0], start_saturated = False}";
      int reported = 0;
      int64_t got;
      int64_t exp;
      arg1 = vcreate_s64(UINT64_C(0x7fff000080006f43));
      clear_neon_saturated();
      //  Expect: "result" = 7fff000080006f43
      result = vget_lane_s64(arg1, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = INT64_C(9223090564025577283);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIi64 " Got: %" PRIi64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1754() {

{
   {
      uint64x1_t arg1;
      uint64_t result;
      char* str1 = "ReproInfo2 {semantics = \"get_lane\", fnname = \"vget_lane_u64\", rettype = \"uint64_t\", argtypes = \"[uint64x1_t,__constrange(0,0) int]\", vals = [VectorVal [IntegerVal 9223372039002236923],IndexVal 0], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u64(UINT64_C(0x800000007fffa7fb));
      clear_neon_saturated();
      //  Expect: "result" = 800000007fffa7fb
      result = vget_lane_u64(arg1, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = UINT64_C(0x800000007fffa7fb);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1755() {

{
   {
      poly64x1_t arg1;
      poly64_t result;
      char* str1 = "ReproInfo2 {semantics = \"get_lane\", fnname = \"vget_lane_p64\", rettype = \"poly64_t\", argtypes = \"[poly64x1_t,__constrange(0,0) int]\", vals = [VectorVal [PolyVal [0,0,0,1,0,0,0,1,1,1,1,0,1,0,0,1,1,0,0,1,1,0,1,1,1,1,0,0,1,0,1,1,0,1,1,1,1,0,1,1,1,0,0,1,0,1,1,0,1,0,1,0,1,1,1,1,0,1,0,1,0,0,1,1]],IndexVal 0], start_saturated = False}";
      int reported = 0;
      poly64_t got;
      poly64_t exp;
      arg1 = vcreate_p64(UINT64_C(0xcaf569ded3d99788));
      clear_neon_saturated();
      //  Expect: "result" = caf569ded3d99788
      result = vget_lane_p64(arg1, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = -3822032302996088952;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIu64 " Got: %" PRIu64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1756() {

{
   {
      uint8x16_t arg1;
      uint8_t result;
      char* str1 = "ReproInfo2 {semantics = \"get_lane\", fnname = \"vgetq_lane_u8\", rettype = \"uint8_t\", argtypes = \"[uint8x16_t,__constrange(0,15) int]\", vals = [VectorVal [IntegerVal 0,IntegerVal 128,IntegerVal 247,IntegerVal 255,IntegerVal 128,IntegerVal 127,IntegerVal 0,IntegerVal 128,IntegerVal 0,IntegerVal 145,IntegerVal 128,IntegerVal 127,IntegerVal 127,IntegerVal 244,IntegerVal 0,IntegerVal 255],IndexVal 7], start_saturated = False}";
      int reported = 0;
      uint8_t got;
      uint8_t exp;
      arg1 = vcombine_u8(vcreate_u8(UINT64_C(0x80007f80fff78000)),
                         vcreate_u8(UINT64_C(0xff00f47f7f809100)));
      clear_neon_saturated();
      //  Expect: "result" = 80
      result = vgetq_lane_u8(arg1, 7);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = 128U;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1757() {

{
   {
      poly8x16_t arg1;
      poly8_t result;
      char* str1 = "ReproInfo2 {semantics = \"get_lane\", fnname = \"vgetq_lane_p8\", rettype = \"poly8_t\", argtypes = \"[poly8x16_t,__constrange(0,15) int]\", vals = [VectorVal [PolyVal [1,0,1,0,1,1,1,0],PolyVal [1,0,0,0,0,1,0,1],PolyVal [0,1,1,1,1,0,1,1],PolyVal [1,1,1,0,0,1,1,1],PolyVal [1,1,1,1,0,1,1,0],PolyVal [1,0,1,1,1,0,0,1],PolyVal [1,1,1,0,1,0,0,0],PolyVal [0,0,0,0,0,1,1,1],PolyVal [1,1,0,0,1,1,1,1],PolyVal [0,0,0,1,1,0,1,1],PolyVal [1,1,1,0,1,1,0,0],PolyVal [0,1,1,1,0,0,1,0],PolyVal [1,0,1,0,0,1,0,1],PolyVal [0,0,1,0,0,1,0,0],PolyVal [1,0,1,1,1,0,0,0],PolyVal [1,0,1,1,0,0,1,1]],IndexVal 10], start_saturated = False}";
      int reported = 0;
      poly8_t got;
      poly8_t exp;
      arg1 = vcombine_p8(vcreate_p8(UINT64_C(0xe0179d6fe7dea175)),
                         vcreate_p8(UINT64_C(0xcd1d24a54e37d8f3)));
      clear_neon_saturated();
      //  Expect: "result" = 37
      result = vgetq_lane_p8(arg1, 10);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = 55;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1758() {

{
   {
      uint16x8_t arg1;
      uint16_t result;
      char* str1 = "ReproInfo2 {semantics = \"get_lane\", fnname = \"vgetq_lane_u16\", rettype = \"uint16_t\", argtypes = \"[uint16x8_t,__constrange(0,7) int]\", vals = [VectorVal [IntegerVal 32768,IntegerVal 0,IntegerVal 56728,IntegerVal 32768,IntegerVal 32768,IntegerVal 61107,IntegerVal 32768,IntegerVal 9634],IndexVal 1], start_saturated = False}";
      int reported = 0;
      uint16_t got;
      uint16_t exp;
      arg1 = vcombine_u16(vcreate_u16(UINT64_C(0x8000dd9800008000)),
                          vcreate_u16(UINT64_C(0x25a28000eeb38000)));
      clear_neon_saturated();
      //  Expect: "result" = 0000
      result = vgetq_lane_u16(arg1, 1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = 0;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1759() {

{
   {
      poly16x8_t arg1;
      poly16_t result;
      char* str1 = "ReproInfo2 {semantics = \"get_lane\", fnname = \"vgetq_lane_p16\", rettype = \"poly16_t\", argtypes = \"[poly16x8_t,__constrange(0,7) int]\", vals = [VectorVal [PolyVal [1,1,1,0,0,1,0,0,0,0,0,0,1,1,0,1],PolyVal [0,1,1,1,0,0,1,1,0,1,1,0,0,1,1,0],PolyVal [1,1,0,0,0,0,0,1,1,0,0,1,0,0,1,0],PolyVal [1,1,0,1,1,1,0,0,1,1,1,1,1,0,0,1],PolyVal [0,1,1,1,0,0,0,1,0,1,0,1,1,0,1,0],PolyVal [0,0,0,1,0,1,1,0,1,1,0,1,1,1,1,1],PolyVal [0,1,0,0,0,1,1,1,1,1,1,0,0,1,0,1],PolyVal [0,1,0,1,1,1,0,1,1,1,1,1,0,1,0,1]],IndexVal 6], start_saturated = False}";
      int reported = 0;
      poly16_t got;
      poly16_t exp;
      arg1 = vcombine_p16(vcreate_p16(UINT64_C(0x9f3b498366ceb027)),
                          vcreate_p16(UINT64_C(0xafbaa7e2fb685a8e)));
      clear_neon_saturated();
      //  Expect: "result" = a7e2
      result = vgetq_lane_p16(arg1, 6);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = 42978;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1760() {

{
   {
      uint32x4_t arg1;
      uint32_t result;
      char* str1 = "ReproInfo2 {semantics = \"get_lane\", fnname = \"vgetq_lane_u32\", rettype = \"uint32_t\", argtypes = \"[uint32x4_t,__constrange(0,3) int]\", vals = [VectorVal [IntegerVal 2147516415,IntegerVal 32768,IntegerVal 2147533054,IntegerVal 4294934527],IndexVal 1], start_saturated = False}";
      int reported = 0;
      uint32_t got;
      uint32_t exp;
      arg1 = vcombine_u32(vcreate_u32(UINT64_C(0x0000800080007fff)),
                          vcreate_u32(UINT64_C(0xffff7fff8000c0fe)));
      clear_neon_saturated();
      //  Expect: "result" = 00008000
      result = vgetq_lane_u32(arg1, 1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = 32768U;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIu32 " Got: %" PRIu32 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1761() {

{
   {
      int64x2_t arg1;
      int64_t result;
      char* str1 = "ReproInfo2 {semantics = \"get_lane\", fnname = \"vgetq_lane_s64\", rettype = \"int64_t\", argtypes = \"[int64x2_t,__constrange(0,1) int]\", vals = [VectorVal [IntegerVal 8438056856126980096,IntegerVal 9223372034707259391],IndexVal 1], start_saturated = False}";
      int reported = 0;
      int64_t got;
      int64_t exp;
      arg1 = vcombine_s64(vcreate_s64(UINT64_C(0x751a0000ffff8000)),
                          vcreate_s64(UINT64_C(0x7fffffff7fff7fff)));
      clear_neon_saturated();
      //  Expect: "result" = 7fffffff7fff7fff
      result = vgetq_lane_s64(arg1, 1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = INT64_C(9223372034707259391);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIi64 " Got: %" PRIi64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1762() {

{
   {
      uint64x2_t arg1;
      uint64_t result;
      char* str1 = "ReproInfo2 {semantics = \"get_lane\", fnname = \"vgetq_lane_u64\", rettype = \"uint64_t\", argtypes = \"[uint64x2_t,__constrange(0,1) int]\", vals = [VectorVal [IntegerVal 9223231299366420479,IntegerVal 9223512774343156254],IndexVal 0], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcombine_u64(vcreate_u64(UINT64_C(0x7fff7fffffffffff)),
                          vcreate_u64(UINT64_C(0x800080000000621e)));
      clear_neon_saturated();
      //  Expect: "result" = 7fff7fffffffffff
      result = vgetq_lane_u64(arg1, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = UINT64_C(0x7fff7fffffffffff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1763() {

{
   {
      poly64x2_t arg1;
      poly64_t result;
      char* str1 = "ReproInfo2 {semantics = \"get_lane\", fnname = \"vgetq_lane_p64\", rettype = \"poly64_t\", argtypes = \"[poly64x2_t,__constrange(0,1) int]\", vals = [VectorVal [PolyVal [0,1,1,0,0,0,0,1,1,1,0,0,0,1,1,0,0,0,0,0,0,1,1,0,1,0,0,0,1,1,1,0,0,1,1,0,1,0,0,1,1,0,1,0,0,0,0,1,0,1,0,1,1,1,1,1,1,0,0,0,1,1,0,0],PolyVal [1,1,1,0,1,1,0,0,0,1,1,0,0,0,1,1,1,1,1,1,0,0,0,1,0,0,0,1,0,0,0,1,1,1,1,0,1,0,0,1,0,1,0,1,1,1,1,1,1,1,0,0,1,1,0,0,1,1,0,0,1,1,0,1]],IndexVal 0], start_saturated = False}";
      int reported = 0;
      poly64_t got;
      poly64_t exp;
      arg1 = vcombine_p64(vcreate_p64(UINT64_C(0x31fa859671606386)),
                          vcreate_p64(UINT64_C(0xb333fa97888fc637)));
      clear_neon_saturated();
      //  Expect: "result" = 31fa859671606386
      result = vgetq_lane_p64(arg1, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = 3601337733229863814;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIu64 " Got: %" PRIu64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1764() {

{
   {
      float32x2_t arg1;
      float32_t result;
      char* str1 = "ReproInfo2 {semantics = \"get_lane\", fnname = \"vget_lane_f32\", rettype = \"float32_t\", argtypes = \"[float32x2_t,__constrange(0,1) int]\", vals = [VectorVal [FloatVal 0.3410571217536926,FloatVal 0.4039733409881592],IndexVal 1], start_saturated = False}";
      int reported = 0;
      float32_t got;
      float32_t exp;
      arg1 = vcreate_f32(UINT64_C(0x3eced5983eae9f0a));
      clear_neon_saturated();
      //  Expect: "result" = 3eced598
      result = vget_lane_f32(arg1, 1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = ((float32_t) 0.4039733409881592);
      if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %f Got: %f\n", "   ", exp, got);
         }
   }
}
}
void dotests_1765() {
#if __ARM_NEON_FP16_INTRINSICS

{
   {
      float16x4_t arg1;
      __fp16 result;
      char* str1 = "ReproInfo2 {semantics = \"get_lane\", fnname = \"vget_lane_f16\", rettype = \"__fp16\", argtypes = \"[float16x4_t,__constrange(0,3) int]\", vals = [VectorVal [FloatVal (-9.010890195476273),FloatVal 7.349214784129476,FloatVal 9.578152635708012,FloatVal 1.6482089033333143],IndexVal 2], start_saturated = False}";
      int reported = 0;
      __fp16 got;
      __fp16 exp;
      arg1 = vcreate_f16(UINT64_C(0x3e9748ca4759c881));
      clear_neon_saturated();
      //  Expect: "result" = 48ca
      result = vget_lane_f16(arg1, 2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = 9.578152635708012;
      if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %f Got: %f\n", "   ", exp, got);
         }
   }
}
#endif
}
void dotests_1766() {

{
   {
      float32x4_t arg1;
      float32_t result;
      char* str1 = "ReproInfo2 {semantics = \"get_lane\", fnname = \"vgetq_lane_f32\", rettype = \"float32_t\", argtypes = \"[float32x4_t,__constrange(0,3) int]\", vals = [VectorVal [FloatVal 0.3813318610191345,FloatVal 5.7924628257751465e-2,FloatVal 0.6281042695045471,FloatVal 0.5984973311424255],IndexVal 3], start_saturated = False}";
      int reported = 0;
      float32_t got;
      float32_t exp;
      arg1 = vcombine_f32(vcreate_f32(UINT64_C(0x3d6d42603ec33dee)),
                          vcreate_f32(UINT64_C(0x3f19371f3f20cb71)));
      clear_neon_saturated();
      //  Expect: "result" = 3f19371f
      result = vgetq_lane_f32(arg1, 3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = ((float32_t) 0.5984973311424255);
      if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %f Got: %f\n", "   ", exp, got);
         }
   }
}
}
void dotests_1767() {

{
   {
      float64x2_t arg1;
      float64_t result;
      char* str1 = "ReproInfo2 {semantics = \"get_lane\", fnname = \"vgetq_lane_f64\", rettype = \"float64_t\", argtypes = \"[float64x2_t,__constrange(0,1) int]\", vals = [VectorVal [FloatVal 0.9861261414057486,FloatVal 0.8104405451011175],IndexVal 1], start_saturated = False}";
      int reported = 0;
      float64_t got;
      float64_t exp;
      arg1 = vcombine_f64(vcreate_f64(UINT64_C(0x3fef8e5868e23005)),
                          vcreate_f64(UINT64_C(0x3fe9ef210291f98d)));
      clear_neon_saturated();
      //  Expect: "result" = 3fe9ef210291f98d
      result = vgetq_lane_f64(arg1, 1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = 0.8104405451011175;
      if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %f Got: %f\n", "   ", exp, got);
         }
   }
}
}
void dotests_1768() {
#if __ARM_NEON_FP16_INTRINSICS

{
   {
      float16x8_t arg1;
      __fp16 result;
      char* str1 = "ReproInfo2 {semantics = \"get_lane\", fnname = \"vgetq_lane_f16\", rettype = \"__fp16\", argtypes = \"[float16x8_t,__constrange(0,7) int]\", vals = [VectorVal [FloatVal 2.59410465613923,FloatVal (-1.1630804033631463),FloatVal (-0.4462008229140686),FloatVal 6.305521670978557,FloatVal 9.378317297668353,FloatVal (-7.257395017719035),FloatVal (-1.674414214621894),FloatVal (-0.8564721142009812)],IndexVal 3], start_saturated = True}";
      int reported = 0;
      __fp16 got;
      __fp16 exp;
      arg1 = vcombine_f16(vcreate_f16(UINT64_C(0x464eb723bca64130)),
                          vcreate_f16(UINT64_C(0xbadabeb2c74148b0)));
      set_neon_saturated();
      //  Expect: "result" = 464e
      result = vgetq_lane_f16(arg1, 3);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      got = result;
      exp = 6.305521670978557;
      if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %f Got: %f\n", "   ", exp, got);
         }
   }
}
#endif
}
void dotests_1769() {

{
   {
      float64x1_t arg1;
      float64_t result;
      char* str1 = "ReproInfo2 {semantics = \"get_lane\", fnname = \"vget_lane_f64\", rettype = \"float64_t\", argtypes = \"[float64x1_t,__constrange(0,0) int]\", vals = [VectorVal [FloatVal 0.9415120394111448],IndexVal 0], start_saturated = False}";
      int reported = 0;
      float64_t got;
      float64_t exp;
      arg1 = vcreate_f64(UINT64_C(0x3fee20dddb41f4c7));
      clear_neon_saturated();
      //  Expect: "result" = 3fee20dddb41f4c7
      result = vget_lane_f64(arg1, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = 0.9415120394111448;
      if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %f Got: %f\n", "   ", exp, got);
         }
   }
}
}
void dotests_1770() {

{
   {
      uint8_t arg1;
      uint8x8_t arg2;
      uint8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"set_lane\", fnname = \"vset_lane_u8\", rettype = \"uint8x8_t\", argtypes = \"[uint8_t,uint8x8_t,__constrange(0,7) int]\", vals = [IntegerVal 193,VectorVal [IntegerVal 0,IntegerVal 127,IntegerVal 127,IntegerVal 255,IntegerVal 128,IntegerVal 128,IntegerVal 0,IntegerVal 128],IndexVal 1], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = 193U;
      arg2 = vcreate_u8(UINT64_C(0x80008080ff7f7f00));
      clear_neon_saturated();
      //  Expect: "result" = 80008080ff7fc100
      result = vset_lane_u8(arg1, arg2, 1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u8(result), 0);
      exp = UINT64_C(0x80008080ff7fc100);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1771() {

{
   {
      uint16_t arg1;
      uint16x4_t arg2;
      uint16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"set_lane\", fnname = \"vset_lane_u16\", rettype = \"uint16x4_t\", argtypes = \"[uint16_t,uint16x4_t,__constrange(0,3) int]\", vals = [IntegerVal 12275,VectorVal [IntegerVal 32767,IntegerVal 65535,IntegerVal 65535,IntegerVal 6239],IndexVal 2], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = 12275U;
      arg2 = vcreate_u16(UINT64_C(0x185fffffffff7fff));
      clear_neon_saturated();
      //  Expect: "result" = 185f2ff3ffff7fff
      result = vset_lane_u16(arg1, arg2, 2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u16(result), 0);
      exp = UINT64_C(0x185f2ff3ffff7fff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1772() {

{
   {
      uint32_t arg1;
      uint32x2_t arg2;
      uint32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"set_lane\", fnname = \"vset_lane_u32\", rettype = \"uint32x2_t\", argtypes = \"[uint32_t,uint32x2_t,__constrange(0,1) int]\", vals = [IntegerVal 2147449441,VectorVal [IntegerVal 2147515575,IntegerVal 2147431425],IndexVal 0], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = 2147449441U;
      arg2 = vcreate_u32(UINT64_C(0x7fff340180007cb7));
      clear_neon_saturated();
      //  Expect: "result" = 7fff34017fff7a61
      result = vset_lane_u32(arg1, arg2, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u32(result), 0);
      exp = UINT64_C(0x7fff34017fff7a61);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1773() {

{
   {
      int8_t arg1;
      int8x8_t arg2;
      int8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"set_lane\", fnname = \"vset_lane_s8\", rettype = \"int8x8_t\", argtypes = \"[int8_t,int8x8_t,__constrange(0,7) int]\", vals = [IntegerVal 98,VectorVal [IntegerVal 127,IntegerVal (-128),IntegerVal 5,IntegerVal 127,IntegerVal 127,IntegerVal 19,IntegerVal 42,IntegerVal 127],IndexVal 3], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = 98;
      arg2 = vcreate_s8(UINT64_C(0x7f2a137f7f05807f));
      clear_neon_saturated();
      //  Expect: "result" = 7f2a137f6205807f
      result = vset_lane_s8(arg1, arg2, 3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s8(result), 0);
      exp = UINT64_C(0x7f2a137f6205807f);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1774() {

{
   {
      int16_t arg1;
      int16x4_t arg2;
      int16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"set_lane\", fnname = \"vset_lane_s16\", rettype = \"int16x4_t\", argtypes = \"[int16_t,int16x4_t,__constrange(0,3) int]\", vals = [IntegerVal 32767,VectorVal [IntegerVal 16470,IntegerVal (-1),IntegerVal 0,IntegerVal (-1)],IndexVal 3], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = 32767;
      arg2 = vcreate_s16(UINT64_C(0xffff0000ffff4056));
      clear_neon_saturated();
      //  Expect: "result" = 7fff0000ffff4056
      result = vset_lane_s16(arg1, arg2, 3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s16(result), 0);
      exp = UINT64_C(0x7fff0000ffff4056);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1775() {

{
   {
      int32_t arg1;
      int32x2_t arg2;
      int32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"set_lane\", fnname = \"vset_lane_s32\", rettype = \"int32x2_t\", argtypes = \"[int32_t,int32x2_t,__constrange(0,1) int]\", vals = [IntegerVal (-65536),VectorVal [IntegerVal (-2147418113),IntegerVal 2147450880],IndexVal 1], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = -65536;
      arg2 = vcreate_s32(UINT64_C(0x7fff80008000ffff));
      clear_neon_saturated();
      //  Expect: "result" = ffff00008000ffff
      result = vset_lane_s32(arg1, arg2, 1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s32(result), 0);
      exp = UINT64_C(0xffff00008000ffff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1776() {

{
   {
      poly8_t arg1;
      poly8x8_t arg2;
      poly8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"set_lane\", fnname = \"vset_lane_p8\", rettype = \"poly8x8_t\", argtypes = \"[poly8_t,poly8x8_t,__constrange(0,7) int]\", vals = [PolyVal [0,1,0,0,1,1,0,1],VectorVal [PolyVal [1,1,1,0,0,1,0,1],PolyVal [0,1,1,1,0,0,1,1],PolyVal [0,0,1,0,1,1,0,0],PolyVal [0,1,0,1,1,1,1,1],PolyVal [0,1,1,0,0,1,0,0],PolyVal [0,0,0,0,1,1,0,1],PolyVal [0,1,0,0,1,1,1,1],PolyVal [0,0,0,1,0,0,0,1]],IndexVal 7], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = 178;
      arg2 = vcreate_p8(UINT64_C(0x88f2b026fa34cea7));
      clear_neon_saturated();
      //  Expect: "result" = b2f2b026fa34cea7
      result = vset_lane_p8(arg1, arg2, 7);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_p8(result), 0);
      exp = UINT64_C(0xb2f2b026fa34cea7);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1777() {

{
   {
      poly16_t arg1;
      poly16x4_t arg2;
      poly16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"set_lane\", fnname = \"vset_lane_p16\", rettype = \"poly16x4_t\", argtypes = \"[poly16_t,poly16x4_t,__constrange(0,3) int]\", vals = [PolyVal [0,1,0,1,1,1,0,0,0,1,1,0,1,1,0,1],VectorVal [PolyVal [1,0,1,1,0,0,1,0,1,1,1,0,0,0,0,1],PolyVal [1,0,0,1,1,0,1,0,1,1,1,0,1,0,1,0],PolyVal [0,1,0,1,1,1,1,0,1,0,1,0,1,1,1,1],PolyVal [0,1,0,0,0,1,1,1,1,1,1,1,0,1,0,1]],IndexVal 2], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = 46650;
      arg2 = vcreate_p16(UINT64_C(0xafe2f57a5759874d));
      clear_neon_saturated();
      //  Expect: "result" = afe2b63a5759874d
      result = vset_lane_p16(arg1, arg2, 2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_p16(result), 0);
      exp = UINT64_C(0xafe2b63a5759874d);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1778() {

{
   {
      float32_t arg1;
      float32x2_t arg2;
      float32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"set_lane\", fnname = \"vset_lane_f32\", rettype = \"float32x2_t\", argtypes = \"[float32_t,float32x2_t,__constrange(0,1) int]\", vals = [FloatVal 0.8088631629943848,VectorVal [FloatVal 0.3866678476333618,FloatVal 0.517763078212738],IndexVal 0], start_saturated = False}";
      int reported = 0;
      arg1 = ((float32_t) 0.8088631629943848);
      arg2 = vcreate_f32(UINT64_C(0x3f048c1f3ec5f954));
      clear_neon_saturated();
      //  Expect: "result" = 3f048c1f3f4f11a8
      result = vset_lane_f32(arg1, arg2, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result, 0);
         exp = ((float32_t) 0.8088631629943848);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result, 1);
         exp = ((float32_t) 0.517763078212738);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
   }
}
}
void dotests_1779() {
#if __ARM_NEON_FP16_INTRINSICS

{
   {
      __fp16 arg1;
      float16x4_t arg2;
      float16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"set_lane\", fnname = \"vset_lane_f16\", rettype = \"float16x4_t\", argtypes = \"[__fp16,float16x4_t,__constrange(0,3) int]\", vals = [FloatVal 1.464145821894956,VectorVal [FloatVal 2.8338376238554925,FloatVal (-9.55529191786785),FloatVal 3.624039608357613,FloatVal 5.476352117455935],IndexVal 2], start_saturated = False}";
      int reported = 0;
      arg1 = 1.464145821894956;
      arg2 = vcreate_f16(UINT64_C(0x4579433fc8c741aa));
      clear_neon_saturated();
      //  Expect: "result" = 45793ddbc8c741aa
      result = vset_lane_f16(arg1, arg2, 2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         __fp16 got;
         __fp16 exp;
         got = vget_lane_f16(result, 0);
         exp = 2.8338376238554925;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vget_lane_f16(result, 1);
         exp = -9.55529191786785;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vget_lane_f16(result, 2);
         exp = 1.464145821894956;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 2 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vget_lane_f16(result, 3);
         exp = 5.476352117455935;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 3 ", exp, got);
            }
      }
   }
}
#endif
}
void dotests_1780() {

{
   {
      uint8_t arg1;
      uint8x16_t arg2;
      uint8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"set_lane\", fnname = \"vsetq_lane_u8\", rettype = \"uint8x16_t\", argtypes = \"[uint8_t,uint8x16_t,__constrange(0,15) int]\", vals = [IntegerVal 0,VectorVal [IntegerVal 127,IntegerVal 127,IntegerVal 0,IntegerVal 67,IntegerVal 255,IntegerVal 127,IntegerVal 177,IntegerVal 255,IntegerVal 127,IntegerVal 0,IntegerVal 255,IntegerVal 0,IntegerVal 0,IntegerVal 127,IntegerVal 0,IntegerVal 0],IndexVal 8], start_saturated = False}";
      int reported = 0;
      arg1 = 0;
      arg2 = vcombine_u8(vcreate_u8(UINT64_C(0xffb17fff43007f7f)),
                         vcreate_u8(UINT64_C(0x00007f0000ff007f)));
      clear_neon_saturated();
      //  Expect: "result" = 00007f0000ff0000ffb17fff43007f7f
      result = vsetq_lane_u8(arg1, arg2, 8);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 0);
         exp = UINT64_C(0xffb17fff43007f7f);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 1);
         exp = UINT64_C(0x00007f0000ff0000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1781() {

{
   {
      uint16_t arg1;
      uint16x8_t arg2;
      uint16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"set_lane\", fnname = \"vsetq_lane_u16\", rettype = \"uint16x8_t\", argtypes = \"[uint16_t,uint16x8_t,__constrange(0,7) int]\", vals = [IntegerVal 32767,VectorVal [IntegerVal 65535,IntegerVal 32768,IntegerVal 0,IntegerVal 27591,IntegerVal 0,IntegerVal 0,IntegerVal 65535,IntegerVal 32767],IndexVal 7], start_saturated = False}";
      int reported = 0;
      arg1 = 32767U;
      arg2 = vcombine_u16(vcreate_u16(UINT64_C(0x6bc700008000ffff)),
                          vcreate_u16(UINT64_C(0x7fffffff00000000)));
      clear_neon_saturated();
      //  Expect: "result" = 7fffffff000000006bc700008000ffff
      result = vsetq_lane_u16(arg1, arg2, 7);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 0);
         exp = UINT64_C(0x6bc700008000ffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 1);
         exp = UINT64_C(0x7fffffff00000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1782() {

{
   {
      uint32_t arg1;
      uint32x4_t arg2;
      uint32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"set_lane\", fnname = \"vsetq_lane_u32\", rettype = \"uint32x4_t\", argtypes = \"[uint32_t,uint32x4_t,__constrange(0,3) int]\", vals = [IntegerVal 185335807,VectorVal [IntegerVal 2147521449,IntegerVal 762707968,IntegerVal 2147505289,IntegerVal 4294934528],IndexVal 2], start_saturated = True}";
      int reported = 0;
      arg1 = 185335807U;
      arg2 = vcombine_u32(vcreate_u32(UINT64_C(0x2d760000800093a9)),
                          vcreate_u32(UINT64_C(0xffff800080005489)));
      set_neon_saturated();
      //  Expect: "result" = ffff80000b0bffff2d760000800093a9
      result = vsetq_lane_u32(arg1, arg2, 2);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 0);
         exp = UINT64_C(0x2d760000800093a9);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 1);
         exp = UINT64_C(0xffff80000b0bffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1783() {

{
   {
      int8_t arg1;
      int8x16_t arg2;
      int8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"set_lane\", fnname = \"vsetq_lane_s8\", rettype = \"int8x16_t\", argtypes = \"[int8_t,int8x16_t,__constrange(0,15) int]\", vals = [IntegerVal (-128),VectorVal [IntegerVal 13,IntegerVal 0,IntegerVal (-1),IntegerVal (-102),IntegerVal 112,IntegerVal (-1),IntegerVal 127,IntegerVal (-128),IntegerVal (-1),IntegerVal (-128),IntegerVal (-63),IntegerVal (-128),IntegerVal (-68),IntegerVal 127,IntegerVal 0,IntegerVal 0],IndexVal 0], start_saturated = False}";
      int reported = 0;
      arg1 = -128;
      arg2 = vcombine_s8(vcreate_s8(UINT64_C(0x807fff709aff000d)),
                         vcreate_s8(UINT64_C(0x00007fbc80c180ff)));
      clear_neon_saturated();
      //  Expect: "result" = 00007fbc80c180ff807fff709aff0080
      result = vsetq_lane_s8(arg1, arg2, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result), 0);
         exp = UINT64_C(0x807fff709aff0080);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result), 1);
         exp = UINT64_C(0x00007fbc80c180ff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1784() {

{
   {
      int16_t arg1;
      int16x8_t arg2;
      int16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"set_lane\", fnname = \"vsetq_lane_s16\", rettype = \"int16x8_t\", argtypes = \"[int16_t,int16x8_t,__constrange(0,7) int]\", vals = [IntegerVal 0,VectorVal [IntegerVal 32767,IntegerVal 13211,IntegerVal 32767,IntegerVal 0,IntegerVal 0,IntegerVal (-32768),IntegerVal (-32768),IntegerVal 32767],IndexVal 6], start_saturated = False}";
      int reported = 0;
      arg1 = 0;
      arg2 = vcombine_s16(vcreate_s16(UINT64_C(0x00007fff339b7fff)),
                          vcreate_s16(UINT64_C(0x7fff800080000000)));
      clear_neon_saturated();
      //  Expect: "result" = 7fff00008000000000007fff339b7fff
      result = vsetq_lane_s16(arg1, arg2, 6);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 0);
         exp = UINT64_C(0x00007fff339b7fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 1);
         exp = UINT64_C(0x7fff000080000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1785() {

{
   {
      int32_t arg1;
      int32x4_t arg2;
      int32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"set_lane\", fnname = \"vsetq_lane_s32\", rettype = \"int32x4_t\", argtypes = \"[int32_t,int32x4_t,__constrange(0,3) int]\", vals = [IntegerVal (-32769),VectorVal [IntegerVal (-1337819136),IntegerVal 2147450879,IntegerVal (-22063),IntegerVal (-1794965504)],IndexVal 0], start_saturated = False}";
      int reported = 0;
      arg1 = -32769;
      arg2 = vcombine_s32(vcreate_s32(UINT64_C(0x7fff7fffb0428000)),
                          vcreate_s32(UINT64_C(0x95030000ffffa9d1)));
      clear_neon_saturated();
      //  Expect: "result" = 95030000ffffa9d17fff7fffffff7fff
      result = vsetq_lane_s32(arg1, arg2, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 0);
         exp = UINT64_C(0x7fff7fffffff7fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 1);
         exp = UINT64_C(0x95030000ffffa9d1);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1786() {

{
   {
      poly8_t arg1;
      poly8x16_t arg2;
      poly8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"set_lane\", fnname = \"vsetq_lane_p8\", rettype = \"poly8x16_t\", argtypes = \"[poly8_t,poly8x16_t,__constrange(0,15) int]\", vals = [PolyVal [0,0,0,0,0,0,0,0],VectorVal [PolyVal [1,0,1,0,0,0,0,1],PolyVal [0,0,0,1,1,0,1,1],PolyVal [1,0,0,0,0,0,0,1],PolyVal [1,1,1,1,1,0,0,0],PolyVal [1,1,1,1,1,1,1,1],PolyVal [0,1,0,0,0,1,1,0],PolyVal [1,1,1,1,0,1,0,0],PolyVal [0,1,0,0,0,1,1,1],PolyVal [0,0,1,0,0,0,0,0],PolyVal [0,1,0,0,0,0,1,1],PolyVal [0,0,1,1,1,1,0,1],PolyVal [1,1,1,0,0,0,1,1],PolyVal [0,1,0,1,0,1,1,0],PolyVal [0,0,1,0,1,1,1,1],PolyVal [1,0,1,0,1,1,0,0],PolyVal [1,1,1,0,1,0,0,1]],IndexVal 10], start_saturated = False}";
      int reported = 0;
      arg1 = 0;
      arg2 = vcombine_p8(vcreate_p8(UINT64_C(0xe22f62ff1f81d885)),
                         vcreate_p8(UINT64_C(0x9735f46ac7bcc204)));
      clear_neon_saturated();
      //  Expect: "result" = 9735f46ac700c204e22f62ff1f81d885
      result = vsetq_lane_p8(arg1, arg2, 10);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p8(result), 0);
         exp = UINT64_C(0xe22f62ff1f81d885);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p8(result), 1);
         exp = UINT64_C(0x9735f46ac700c204);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1787() {

{
   {
      poly16_t arg1;
      poly16x8_t arg2;
      poly16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"set_lane\", fnname = \"vsetq_lane_p16\", rettype = \"poly16x8_t\", argtypes = \"[poly16_t,poly16x8_t,__constrange(0,7) int]\", vals = [PolyVal [0,0,1,1,0,0,1,0,0,0,0,0,1,1,0,1],VectorVal [PolyVal [1,1,0,0,1,0,0,0,0,1,0,1,0,0,0,0],PolyVal [0,1,1,0,1,0,0,1,1,0,0,0,0,0,0,0],PolyVal [1,0,1,0,0,0,0,1,1,0,1,0,0,0,1,0],PolyVal [0,1,0,1,0,1,1,1,1,0,1,0,1,0,1,1],PolyVal [0,1,1,0,0,1,0,0,0,1,1,0,0,1,1,1],PolyVal [1,0,1,1,0,0,0,0,0,0,1,1,1,0,1,1],PolyVal [0,1,1,1,1,1,0,1,1,0,0,0,1,1,1,1],PolyVal [1,0,0,1,0,1,0,0,1,0,1,1,0,1,1,1]],IndexVal 1], start_saturated = False}";
      int reported = 0;
      arg1 = 45132;
      arg2 = vcombine_p16(vcreate_p16(UINT64_C(0xd5ea458501960a13)),
                          vcreate_p16(UINT64_C(0xed29f1bedc0de626)));
      clear_neon_saturated();
      //  Expect: "result" = ed29f1bedc0de626d5ea4585b04c0a13
      result = vsetq_lane_p16(arg1, arg2, 1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p16(result), 0);
         exp = UINT64_C(0xd5ea4585b04c0a13);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p16(result), 1);
         exp = UINT64_C(0xed29f1bedc0de626);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1788() {

{
   {
      float32_t arg1;
      float32x4_t arg2;
      float32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"set_lane\", fnname = \"vsetq_lane_f32\", rettype = \"float32x4_t\", argtypes = \"[float32_t,float32x4_t,__constrange(0,3) int]\", vals = [FloatVal 0.4839489459991455,VectorVal [FloatVal 0.733673632144928,FloatVal 0.5077124238014221,FloatVal 0.15954047441482544,FloatVal 0.7867162823677063],IndexVal 3], start_saturated = False}";
      int reported = 0;
      arg1 = ((float32_t) 0.4839489459991455);
      arg2 = vcombine_f32(vcreate_f32(UINT64_C(0x3f01f9713f3bd209)),
                          vcreate_f32(UINT64_C(0x3f49663d3e235e94)));
      clear_neon_saturated();
      //  Expect: "result" = 3ef7c8283e235e943f01f9713f3bd209
      result = vsetq_lane_f32(arg1, arg2, 3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 0);
         exp = ((float32_t) 0.733673632144928);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 1);
         exp = ((float32_t) 0.5077124238014221);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 2);
         exp = ((float32_t) 0.15954047441482544);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 2 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 3);
         exp = ((float32_t) 0.4839489459991455);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 3 ", exp, got);
            }
      }
   }
}
}
void dotests_1789() {
#if __ARM_NEON_FP16_INTRINSICS

{
   {
      __fp16 arg1;
      float16x8_t arg2;
      float16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"set_lane\", fnname = \"vsetq_lane_f16\", rettype = \"float16x8_t\", argtypes = \"[__fp16,float16x8_t,__constrange(0,7) int]\", vals = [FloatVal 8.452492093489813,VectorVal [FloatVal 4.163257989824714,FloatVal 9.323983396105678,FloatVal (-2.400060544242379),FloatVal (-7.945919022443089),FloatVal 7.947918171842442,FloatVal (-5.409341506102818),FloatVal 4.137854104148824,FloatVal 7.3548166408692985],IndexVal 5], start_saturated = True}";
      int reported = 0;
      arg1 = 8.452492093489813;
      arg2 = vcombine_f16(vcreate_f16(UINT64_C(0xc7f2c0cc48a94429)),
                          vcreate_f16(UINT64_C(0x475a4423c56847f2)));
      set_neon_saturated();
      //  Expect: "result" = 475a4423483947f2c7f2c0cc48a94429
      result = vsetq_lane_f16(arg1, arg2, 5);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result, 0);
         exp = 4.163257989824714;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result, 1);
         exp = 9.323983396105678;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result, 2);
         exp = -2.400060544242379;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 2 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result, 3);
         exp = -7.945919022443089;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 3 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result, 4);
         exp = 7.947918171842442;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 4 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result, 5);
         exp = 8.452492093489813;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 5 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result, 6);
         exp = 4.137854104148824;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 6 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result, 7);
         exp = 7.3548166408692985;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 7 ", exp, got);
            }
      }
   }
}
#endif
}
void dotests_1790() {

{
   {
      int64_t arg1;
      int64x1_t arg2;
      int64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"set_lane\", fnname = \"vset_lane_s64\", rettype = \"int64x1_t\", argtypes = \"[int64_t,int64x1_t,__constrange(0,0) int]\", vals = [IntegerVal 9223137540230283264,VectorVal [IntegerVal (-9223231301513936896)],IndexVal 0], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = INT64_C(9223137540230283264);
      arg2 = vcreate_s64(UINT64_C(0x80007fff7fff8000));
      clear_neon_saturated();
      //  Expect: "result" = 7fff2ab9ffff0000
      result = vset_lane_s64(arg1, arg2, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s64(result), 0);
      exp = UINT64_C(0x7fff2ab9ffff0000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1791() {

{
   {
      uint64_t arg1;
      uint64x1_t arg2;
      uint64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"set_lane\", fnname = \"vset_lane_u64\", rettype = \"uint64x1_t\", argtypes = \"[uint64_t,uint64x1_t,__constrange(0,0) int]\", vals = [IntegerVal 9223231302397788160,VectorVal [IntegerVal 11107284055979132968],IndexVal 0], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = UINT64_C(0x7fff8000b4af0000);
      arg2 = vcreate_u64(UINT64_C(0x9a24ffffffff0828));
      clear_neon_saturated();
      //  Expect: "result" = 7fff8000b4af0000
      result = vset_lane_u64(arg1, arg2, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(result, 0);
      exp = UINT64_C(0x7fff8000b4af0000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1792() {

{
   {
      float64_t arg1;
      float64x1_t arg2;
      float64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"set_lane\", fnname = \"vset_lane_f64\", rettype = \"float64x1_t\", argtypes = \"[float64_t,float64x1_t,__constrange(0,0) int]\", vals = [FloatVal 0.9657906326426302,VectorVal [FloatVal 0.12488179777726471],IndexVal 0], start_saturated = False}";
      int reported = 0;
      float64_t got;
      float64_t exp;
      arg1 = 0.9657906326426302;
      arg2 = vcreate_f64(UINT64_C(0x3fbff840e551ac70));
      clear_neon_saturated();
      //  Expect: "result" = 3feee7c1c1bf76c2
      result = vset_lane_f64(arg1, arg2, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_f64(result, 0);
      exp = 0.9657906326426302;
      if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
         }
   }
}
}
void dotests_1793() {

{
   {
      poly64_t arg1;
      poly64x1_t arg2;
      poly64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"set_lane\", fnname = \"vset_lane_p64\", rettype = \"poly64x1_t\", argtypes = \"[poly64_t,poly64x1_t,__constrange(0,0) int]\", vals = [PolyVal [0,1,0,1,0,1,1,1,0,1,1,0,1,1,1,1,0,1,0,0,0,1,0,1,0,0,1,1,1,0,1,1,0,1,1,0,0,0,0,0,1,1,1,1,1,0,1,0,1,1,0,1,0,1,1,1,1,1,1,1,0,0,1,1],VectorVal [PolyVal [1,0,0,0,0,1,1,0,0,1,0,0,1,0,0,0,0,1,1,1,1,1,1,0,1,1,1,0,1,0,1,1,1,0,1,0,0,0,1,0,1,0,1,1,1,1,1,0,1,1,1,0,1,0,1,1,1,0,0,1,0,0,0,0]],IndexVal 0], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = -3464571005255354646;
      arg2 = vcreate_p64(UINT64_C(0x09d77d45d77e1261));
      clear_neon_saturated();
      //  Expect: "result" = cfeb5f06dca2f6ea
      result = vset_lane_p64(arg1, arg2, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_p64(result), 0);
      exp = UINT64_C(0xcfeb5f06dca2f6ea);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1794() {

{
   {
      int64_t arg1;
      int64x2_t arg2;
      int64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"set_lane\", fnname = \"vsetq_lane_s64\", rettype = \"int64x2_t\", argtypes = \"[int64_t,int64x2_t,__constrange(0,1) int]\", vals = [IntegerVal 9223090564753383210,VectorVal [IntegerVal 9223326699180031999,IntegerVal 140739635904511],IndexVal 0], start_saturated = True}";
      int reported = 0;
      arg1 = INT64_C(9223090564753383210);
      arg2 = vcombine_s64(vcreate_s64(UINT64_C(0x7fffd6c400007fff)),
                          vcreate_s64(UINT64_C(0x000080008000ffff)));
      set_neon_saturated();
      //  Expect: "result" = 000080008000ffff7fff0000ab61df2a
      result = vsetq_lane_s64(arg1, arg2, 0);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 0);
         exp = UINT64_C(0x7fff0000ab61df2a);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 1);
         exp = UINT64_C(0x000080008000ffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1795() {

{
   {
      uint64_t arg1;
      uint64x2_t arg2;
      uint64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"set_lane\", fnname = \"vsetq_lane_u64\", rettype = \"uint64x2_t\", argtypes = \"[uint64_t,uint64x2_t,__constrange(0,1) int]\", vals = [IntegerVal 7039829900726960127,VectorVal [IntegerVal 18446462602494672896,IntegerVal 18446603336221163520],IndexVal 1], start_saturated = False}";
      int reported = 0;
      arg1 = UINT64_C(0x61b27fff0000ffff);
      arg2 = vcombine_u64(vcreate_u64(UINT64_C(0xffff0000e0390000)),
                          vcreate_u64(UINT64_C(0xffff7fffffff8000)));
      clear_neon_saturated();
      //  Expect: "result" = 61b27fff0000ffffffff0000e0390000
      result = vsetq_lane_u64(arg1, arg2, 1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 0);
         exp = UINT64_C(0xffff0000e0390000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 1);
         exp = UINT64_C(0x61b27fff0000ffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1796() {

{
   {
      float64_t arg1;
      float64x2_t arg2;
      float64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"set_lane\", fnname = \"vsetq_lane_f64\", rettype = \"float64x2_t\", argtypes = \"[float64_t,float64x2_t,__constrange(0,1) int]\", vals = [FloatVal 0.15971730671715845,VectorVal [FloatVal 0.3318678081369866,FloatVal 0.523630172237357],IndexVal 1], start_saturated = False}";
      int reported = 0;
      arg1 = 0.15971730671715845;
      arg2 = vcombine_f64(vcreate_f64(UINT64_C(0x3fd53d5279a2c9b0)),
                          vcreate_f64(UINT64_C(0x3fe0c194101eaa5b)));
      clear_neon_saturated();
      //  Expect: "result" = 3fc4719de07a4a703fd53d5279a2c9b0
      result = vsetq_lane_f64(arg1, arg2, 1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float64_t got;
         float64_t exp;
         got = vgetq_lane_f64(result, 0);
         exp = 0.3318678081369866;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float64_t got;
         float64_t exp;
         got = vgetq_lane_f64(result, 1);
         exp = 0.15971730671715845;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
   }
}
}
void dotests_1797() {

{
   {
      poly64_t arg1;
      poly64x2_t arg2;
      poly64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"set_lane\", fnname = \"vsetq_lane_p64\", rettype = \"poly64x2_t\", argtypes = \"[poly64_t,poly64x2_t,__constrange(0,1) int]\", vals = [PolyVal [1,1,1,0,0,1,0,1,1,0,0,0,0,1,1,0,1,1,1,1,1,0,0,1,0,1,0,0,1,0,0,0,0,0,1,0,1,0,0,0,1,1,0,0,0,1,1,1,0,1,0,1,0,0,1,0,1,1,1,0,1,0,1,0],VectorVal [PolyVal [1,1,1,0,0,0,1,0,1,1,0,0,0,0,1,1,0,1,1,0,1,1,0,1,1,1,0,1,1,1,0,1,0,1,0,1,1,0,1,1,0,0,0,0,0,0,1,0,0,1,1,1,0,1,1,1,0,1,1,0,1,0,1,0],PolyVal [1,1,1,1,0,0,1,1,1,0,0,1,0,1,0,0,0,0,0,0,0,1,1,1,1,0,1,0,1,0,1,0,1,1,0,0,0,0,0,0,1,0,0,1,1,0,0,1,1,1,1,0,1,1,0,0,1,0,1,0,0,1,1,1]],IndexVal 1], start_saturated = False}";
      int reported = 0;
      arg1 = 6290089504927605159;
      arg2 = vcombine_p64(vcreate_p64(UINT64_C(0x56ee40dabbb6c347)),
                          vcreate_p64(UINT64_C(0xe537990355e029cf)));
      clear_neon_saturated();
      //  Expect: "result" = 574ae314129f61a756ee40dabbb6c347
      result = vsetq_lane_p64(arg1, arg2, 1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p64(result), 0);
         exp = UINT64_C(0x56ee40dabbb6c347);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p64(result), 1);
         exp = UINT64_C(0x574ae314129f61a7);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1798() {

{
   {
      int8x16_t arg1;
      int8x16_t arg3;
      int8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"ins_lane\", fnname = \"vcopyq_laneq_s8\", rettype = \"int8x16_t\", argtypes = \"[int8x16_t,__constrange(0,15) int,int8x16_t,__constrange(0,15) int]\", vals = [VectorVal [IntegerVal (-128),IntegerVal 0,IntegerVal 106,IntegerVal 127,IntegerVal (-128),IntegerVal 70,IntegerVal 85,IntegerVal 127,IntegerVal (-84),IntegerVal 0,IntegerVal 127,IntegerVal (-1),IntegerVal 0,IntegerVal 25,IntegerVal 114,IntegerVal (-128)],IndexVal 11,VectorVal [IntegerVal 0,IntegerVal 127,IntegerVal 0,IntegerVal 127,IntegerVal 35,IntegerVal (-128),IntegerVal 0,IntegerVal (-1),IntegerVal (-128),IntegerVal (-1),IntegerVal 0,IntegerVal (-128),IntegerVal 112,IntegerVal 127,IntegerVal (-128),IntegerVal 0],IndexVal 5], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s8(vcreate_s8(UINT64_C(0x7f5546807f6a0080)),
                         vcreate_s8(UINT64_C(0x80721900ff7f00ac)));
      arg3 = vcombine_s8(vcreate_s8(UINT64_C(0xff0080237f007f00)),
                         vcreate_s8(UINT64_C(0x00807f708000ff80)));
      clear_neon_saturated();
      //  Expect: "result" = 80721900807f00ac7f5546807f6a0080
      result = vcopyq_laneq_s8(arg1, 11, arg3, 5);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result), 0);
         exp = UINT64_C(0x7f5546807f6a0080);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result), 1);
         exp = UINT64_C(0x80721900807f00ac);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1799() {

{
   {
      int8x16_t arg1;
      int8x8_t arg3;
      int8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"ins_lane\", fnname = \"vcopyq_lane_s8\", rettype = \"int8x16_t\", argtypes = \"[int8x16_t,__constrange(0,15) int,int8x8_t,__constrange(0,7) int]\", vals = [VectorVal [IntegerVal (-128),IntegerVal (-128),IntegerVal (-3),IntegerVal (-117),IntegerVal (-1),IntegerVal (-1),IntegerVal (-1),IntegerVal 127,IntegerVal (-1),IntegerVal (-128),IntegerVal (-1),IntegerVal (-128),IntegerVal (-1),IntegerVal (-128),IntegerVal (-128),IntegerVal 77],IndexVal 11,VectorVal [IntegerVal 127,IntegerVal (-1),IntegerVal 0,IntegerVal 0,IntegerVal (-128),IntegerVal (-1),IntegerVal (-1),IntegerVal (-1)],IndexVal 4], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s8(vcreate_s8(UINT64_C(0x7fffffff8bfd8080)),
                         vcreate_s8(UINT64_C(0x4d8080ff80ff80ff)));
      arg3 = vcreate_s8(UINT64_C(0xffffff800000ff7f));
      clear_neon_saturated();
      //  Expect: "result" = 4d8080ff80ff80ff7fffffff8bfd8080
      result = vcopyq_lane_s8(arg1, 11, arg3, 4);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result), 0);
         exp = UINT64_C(0x7fffffff8bfd8080);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result), 1);
         exp = UINT64_C(0x4d8080ff80ff80ff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1800() {

{
   {
      uint8x16_t arg1;
      uint8x16_t arg3;
      uint8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"ins_lane\", fnname = \"vcopyq_laneq_u8\", rettype = \"uint8x16_t\", argtypes = \"[uint8x16_t,__constrange(0,15) int,uint8x16_t,__constrange(0,15) int]\", vals = [VectorVal [IntegerVal 0,IntegerVal 117,IntegerVal 127,IntegerVal 255,IntegerVal 0,IntegerVal 255,IntegerVal 255,IntegerVal 219,IntegerVal 127,IntegerVal 255,IntegerVal 255,IntegerVal 127,IntegerVal 128,IntegerVal 128,IntegerVal 255,IntegerVal 214],IndexVal 3,VectorVal [IntegerVal 127,IntegerVal 0,IntegerVal 255,IntegerVal 127,IntegerVal 128,IntegerVal 128,IntegerVal 127,IntegerVal 128,IntegerVal 127,IntegerVal 246,IntegerVal 170,IntegerVal 0,IntegerVal 0,IntegerVal 128,IntegerVal 0,IntegerVal 127],IndexVal 14], start_saturated = True}";
      int reported = 0;
      arg1 = vcombine_u8(vcreate_u8(UINT64_C(0xdbffff00ff7f7500)),
                         vcreate_u8(UINT64_C(0xd6ff80807fffff7f)));
      arg3 = vcombine_u8(vcreate_u8(UINT64_C(0x807f80807fff007f)),
                         vcreate_u8(UINT64_C(0x7f00800000aaf67f)));
      set_neon_saturated();
      //  Expect: "result" = d6ff80807fffff7fdbffff00007f7500
      result = vcopyq_laneq_u8(arg1, 3, arg3, 14);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 0);
         exp = UINT64_C(0xdbffff00007f7500);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 1);
         exp = UINT64_C(0xd6ff80807fffff7f);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1801() {

{
   {
      uint8x16_t arg1;
      uint8x8_t arg3;
      uint8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"ins_lane\", fnname = \"vcopyq_lane_u8\", rettype = \"uint8x16_t\", argtypes = \"[uint8x16_t,__constrange(0,15) int,uint8x8_t,__constrange(0,7) int]\", vals = [VectorVal [IntegerVal 128,IntegerVal 128,IntegerVal 128,IntegerVal 128,IntegerVal 127,IntegerVal 0,IntegerVal 25,IntegerVal 128,IntegerVal 165,IntegerVal 255,IntegerVal 255,IntegerVal 255,IntegerVal 255,IntegerVal 0,IntegerVal 255,IntegerVal 0],IndexVal 14,VectorVal [IntegerVal 109,IntegerVal 127,IntegerVal 227,IntegerVal 255,IntegerVal 128,IntegerVal 255,IntegerVal 231,IntegerVal 0],IndexVal 4], start_saturated = True}";
      int reported = 0;
      arg1 = vcombine_u8(vcreate_u8(UINT64_C(0x8019007f80808080)),
                         vcreate_u8(UINT64_C(0x00ff00ffffffffa5)));
      arg3 = vcreate_u8(UINT64_C(0x00e7ff80ffe37f6d));
      set_neon_saturated();
      //  Expect: "result" = 008000ffffffffa58019007f80808080
      result = vcopyq_lane_u8(arg1, 14, arg3, 4);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 0);
         exp = UINT64_C(0x8019007f80808080);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 1);
         exp = UINT64_C(0x008000ffffffffa5);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1802() {

{
   {
      poly8x16_t arg1;
      poly8x16_t arg3;
      poly8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"ins_lane\", fnname = \"vcopyq_laneq_p8\", rettype = \"poly8x16_t\", argtypes = \"[poly8x16_t,__constrange(0,15) int,poly8x16_t,__constrange(0,15) int]\", vals = [VectorVal [PolyVal [0,1,1,0,0,0,1,0],PolyVal [0,1,1,0,1,1,0,1],PolyVal [0,0,1,0,1,1,0,1],PolyVal [0,0,1,0,0,1,0,1],PolyVal [1,0,1,0,1,1,0,0],PolyVal [0,1,0,0,1,0,0,1],PolyVal [1,0,1,1,0,1,1,1],PolyVal [1,1,0,0,0,0,1,1],PolyVal [1,1,1,0,0,1,0,1],PolyVal [0,1,0,1,1,0,0,0],PolyVal [1,0,1,0,1,0,1,0],PolyVal [1,0,1,0,0,0,1,0],PolyVal [0,1,0,1,0,1,1,1],PolyVal [0,1,0,0,0,1,1,1],PolyVal [1,1,1,0,1,1,1,1],PolyVal [0,0,1,0,1,0,0,0]],IndexVal 2,VectorVal [PolyVal [0,0,0,1,1,0,0,1],PolyVal [1,0,0,0,0,0,1,1],PolyVal [0,0,1,0,0,1,1,1],PolyVal [1,0,1,1,0,0,1,1],PolyVal [1,1,0,1,1,0,1,1],PolyVal [1,1,1,1,1,0,0,0],PolyVal [1,1,0,0,0,0,0,1],PolyVal [0,0,1,1,0,1,0,1],PolyVal [1,0,1,1,1,0,0,1],PolyVal [0,1,1,0,0,0,0,0],PolyVal [1,1,1,0,1,1,0,0],PolyVal [0,1,1,1,0,0,0,1],PolyVal [0,0,1,1,0,1,0,1],PolyVal [1,1,1,1,0,1,1,1],PolyVal [0,0,0,1,0,0,1,0],PolyVal [0,0,0,0,0,1,1,0]],IndexVal 7], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_p8(vcreate_p8(UINT64_C(0xc3ed9235a4b4b646)),
                         vcreate_p8(UINT64_C(0x14f7e2ea45551aa7)));
      arg3 = vcombine_p8(vcreate_p8(UINT64_C(0xac831fdbcde4c198)),
                         vcreate_p8(UINT64_C(0x6048efac8e37069d)));
      clear_neon_saturated();
      //  Expect: "result" = 14f7e2ea45551aa7c3ed9235a4acb646
      result = vcopyq_laneq_p8(arg1, 2, arg3, 7);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p8(result), 0);
         exp = UINT64_C(0xc3ed9235a4acb646);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p8(result), 1);
         exp = UINT64_C(0x14f7e2ea45551aa7);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1803() {

{
   {
      poly8x16_t arg1;
      poly8x8_t arg3;
      poly8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"ins_lane\", fnname = \"vcopyq_lane_p8\", rettype = \"poly8x16_t\", argtypes = \"[poly8x16_t,__constrange(0,15) int,poly8x8_t,__constrange(0,7) int]\", vals = [VectorVal [PolyVal [1,0,1,1,1,1,0,0],PolyVal [1,1,0,0,0,1,1,0],PolyVal [1,1,1,1,0,1,1,1],PolyVal [1,0,0,1,0,0,1,0],PolyVal [0,0,1,1,1,1,0,1],PolyVal [1,0,1,1,0,1,0,1],PolyVal [0,1,1,1,0,1,0,0],PolyVal [0,0,0,1,1,0,1,0],PolyVal [0,0,1,1,0,0,1,0],PolyVal [0,1,0,0,1,1,1,0],PolyVal [1,1,0,0,1,1,0,1],PolyVal [1,1,1,0,0,0,1,1],PolyVal [0,0,1,0,1,0,0,1],PolyVal [1,1,1,0,1,0,0,1],PolyVal [0,0,1,0,1,1,0,1],PolyVal [0,1,0,1,1,1,0,1]],IndexVal 3,VectorVal [PolyVal [1,1,1,0,0,1,1,0],PolyVal [0,0,1,0,0,1,1,0],PolyVal [0,1,1,0,0,0,0,1],PolyVal [1,0,0,1,1,0,0,0],PolyVal [0,1,1,0,1,1,1,1],PolyVal [1,1,1,0,0,0,0,0],PolyVal [1,0,0,1,0,0,1,1],PolyVal [0,0,1,0,0,0,1,1]],IndexVal 6], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_p8(vcreate_p8(UINT64_C(0x582eadbc49ef633d)),
                         vcreate_p8(UINT64_C(0xbab49794c7b3724c)));
      arg3 = vcreate_p8(UINT64_C(0xc4c907f619866467));
      clear_neon_saturated();
      //  Expect: "result" = bab49794c7b3724c582eadbcc9ef633d
      result = vcopyq_lane_p8(arg1, 3, arg3, 6);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p8(result), 0);
         exp = UINT64_C(0x582eadbcc9ef633d);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p8(result), 1);
         exp = UINT64_C(0xbab49794c7b3724c);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1804() {

{
   {
      int16x8_t arg1;
      int16x8_t arg3;
      int16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"ins_lane\", fnname = \"vcopyq_laneq_s16\", rettype = \"int16x8_t\", argtypes = \"[int16x8_t,__constrange(0,7) int,int16x8_t,__constrange(0,7) int]\", vals = [VectorVal [IntegerVal 9696,IntegerVal 0,IntegerVal (-32768),IntegerVal (-1),IntegerVal (-25245),IntegerVal (-1),IntegerVal 20841,IntegerVal 0],IndexVal 2,VectorVal [IntegerVal 32767,IntegerVal 0,IntegerVal 32767,IntegerVal (-32768),IntegerVal 0,IntegerVal (-1),IntegerVal (-32768),IntegerVal 32767],IndexVal 5], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s16(vcreate_s16(UINT64_C(0xffff8000000025e0)),
                          vcreate_s16(UINT64_C(0x00005169ffff9d63)));
      arg3 = vcombine_s16(vcreate_s16(UINT64_C(0x80007fff00007fff)),
                          vcreate_s16(UINT64_C(0x7fff8000ffff0000)));
      clear_neon_saturated();
      //  Expect: "result" = 00005169ffff9d63ffffffff000025e0
      result = vcopyq_laneq_s16(arg1, 2, arg3, 5);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 0);
         exp = UINT64_C(0xffffffff000025e0);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 1);
         exp = UINT64_C(0x00005169ffff9d63);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1805() {

{
   {
      int16x8_t arg1;
      int16x4_t arg3;
      int16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"ins_lane\", fnname = \"vcopyq_lane_s16\", rettype = \"int16x8_t\", argtypes = \"[int16x8_t,__constrange(0,7) int,int16x4_t,__constrange(0,3) int]\", vals = [VectorVal [IntegerVal (-32768),IntegerVal (-32768),IntegerVal 32767,IntegerVal 32767,IntegerVal (-1),IntegerVal (-1),IntegerVal 0,IntegerVal 0],IndexVal 1,VectorVal [IntegerVal (-32768),IntegerVal 32767,IntegerVal 31803,IntegerVal (-32768)],IndexVal 3], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s16(vcreate_s16(UINT64_C(0x7fff7fff80008000)),
                          vcreate_s16(UINT64_C(0x00000000ffffffff)));
      arg3 = vcreate_s16(UINT64_C(0x80007c3b7fff8000));
      clear_neon_saturated();
      //  Expect: "result" = 00000000ffffffff7fff7fff80008000
      result = vcopyq_lane_s16(arg1, 1, arg3, 3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 0);
         exp = UINT64_C(0x7fff7fff80008000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 1);
         exp = UINT64_C(0x00000000ffffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1806() {

{
   {
      uint16x8_t arg1;
      uint16x8_t arg3;
      uint16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"ins_lane\", fnname = \"vcopyq_laneq_u16\", rettype = \"uint16x8_t\", argtypes = \"[uint16x8_t,__constrange(0,7) int,uint16x8_t,__constrange(0,7) int]\", vals = [VectorVal [IntegerVal 0,IntegerVal 32767,IntegerVal 65535,IntegerVal 0,IntegerVal 32767,IntegerVal 17549,IntegerVal 32768,IntegerVal 32768],IndexVal 4,VectorVal [IntegerVal 65535,IntegerVal 25277,IntegerVal 65535,IntegerVal 32767,IntegerVal 32768,IntegerVal 65535,IntegerVal 65535,IntegerVal 42362],IndexVal 2], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u16(vcreate_u16(UINT64_C(0x0000ffff7fff0000)),
                          vcreate_u16(UINT64_C(0x80008000448d7fff)));
      arg3 = vcombine_u16(vcreate_u16(UINT64_C(0x7fffffff62bdffff)),
                          vcreate_u16(UINT64_C(0xa57affffffff8000)));
      clear_neon_saturated();
      //  Expect: "result" = 80008000448dffff0000ffff7fff0000
      result = vcopyq_laneq_u16(arg1, 4, arg3, 2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 0);
         exp = UINT64_C(0x0000ffff7fff0000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 1);
         exp = UINT64_C(0x80008000448dffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1807() {

{
   {
      uint16x8_t arg1;
      uint16x4_t arg3;
      uint16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"ins_lane\", fnname = \"vcopyq_lane_u16\", rettype = \"uint16x8_t\", argtypes = \"[uint16x8_t,__constrange(0,7) int,uint16x4_t,__constrange(0,3) int]\", vals = [VectorVal [IntegerVal 61943,IntegerVal 32767,IntegerVal 65535,IntegerVal 32767,IntegerVal 32768,IntegerVal 32767,IntegerVal 32767,IntegerVal 65535],IndexVal 7,VectorVal [IntegerVal 32767,IntegerVal 12833,IntegerVal 32768,IntegerVal 36645],IndexVal 0], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u16(vcreate_u16(UINT64_C(0x7fffffff7ffff1f7)),
                          vcreate_u16(UINT64_C(0xffff7fff7fff8000)));
      arg3 = vcreate_u16(UINT64_C(0x8f25800032217fff));
      clear_neon_saturated();
      //  Expect: "result" = 7fff7fff7fff80007fffffff7ffff1f7
      result = vcopyq_lane_u16(arg1, 7, arg3, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 0);
         exp = UINT64_C(0x7fffffff7ffff1f7);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 1);
         exp = UINT64_C(0x7fff7fff7fff8000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1808() {

{
   {
      poly16x8_t arg1;
      poly16x8_t arg3;
      poly16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"ins_lane\", fnname = \"vcopyq_laneq_p16\", rettype = \"poly16x8_t\", argtypes = \"[poly16x8_t,__constrange(0,7) int,poly16x8_t,__constrange(0,7) int]\", vals = [VectorVal [PolyVal [1,0,1,0,0,0,1,0,1,0,0,1,1,1,0,1],PolyVal [1,0,0,1,0,0,0,0,1,1,1,0,1,1,1,0],PolyVal [1,1,1,0,0,1,0,1,0,0,0,1,1,1,0,0],PolyVal [0,0,0,1,1,1,1,0,1,0,0,0,1,1,1,0],PolyVal [0,1,0,1,1,1,1,0,0,1,1,0,0,0,1,1],PolyVal [0,1,1,1,1,1,0,1,1,0,1,1,1,1,1,0],PolyVal [0,0,0,1,0,0,0,0,0,1,1,0,0,1,0,1],PolyVal [1,0,1,1,1,0,1,1,0,1,0,0,1,0,0,0]],IndexVal 1,VectorVal [PolyVal [1,0,0,1,1,1,1,0,0,1,1,1,0,1,1,0],PolyVal [0,1,1,0,1,1,0,1,0,0,0,1,1,0,0,0],PolyVal [0,0,1,1,0,1,1,0,0,0,1,1,0,0,0,0],PolyVal [0,1,0,0,1,0,1,0,1,0,1,1,1,1,1,0],PolyVal [0,0,1,1,1,0,1,0,1,0,1,1,1,0,1,1],PolyVal [0,0,0,0,0,1,1,0,1,1,1,1,0,1,0,1],PolyVal [1,0,0,1,1,0,0,0,0,0,0,1,0,1,0,0],PolyVal [1,0,0,0,1,1,0,0,1,0,1,1,0,0,1,0]],IndexVal 1], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_p16(vcreate_p16(UINT64_C(0x717838a77709b945)),
                          vcreate_p16(UINT64_C(0x12dda6087dbec67a)));
      arg3 = vcombine_p16(vcreate_p16(UINT64_C(0x7d520c6c18b66e79)),
                          vcreate_p16(UINT64_C(0x4d312819af60dd5c)));
      clear_neon_saturated();
      //  Expect: "result" = 12dda6087dbec67a717838a718b6b945
      result = vcopyq_laneq_p16(arg1, 1, arg3, 1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p16(result), 0);
         exp = UINT64_C(0x717838a718b6b945);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p16(result), 1);
         exp = UINT64_C(0x12dda6087dbec67a);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1809() {

{
   {
      poly16x8_t arg1;
      poly16x4_t arg3;
      poly16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"ins_lane\", fnname = \"vcopyq_lane_p16\", rettype = \"poly16x8_t\", argtypes = \"[poly16x8_t,__constrange(0,7) int,poly16x4_t,__constrange(0,3) int]\", vals = [VectorVal [PolyVal [1,0,1,1,0,1,1,0,1,0,1,1,1,0,1,0],PolyVal [1,1,0,1,0,1,0,1,1,1,0,0,1,1,0,1],PolyVal [0,0,0,1,0,1,1,0,0,0,0,0,1,1,1,1],PolyVal [1,0,0,1,0,1,0,1,1,1,1,0,0,1,1,0],PolyVal [0,0,0,0,1,1,0,1,1,0,1,0,1,0,1,0],PolyVal [1,0,0,0,0,1,0,0,0,0,1,0,1,1,0,1],PolyVal [0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,1],PolyVal [0,0,0,0,0,1,1,0,0,1,1,0,0,1,1,0]],IndexVal 3,VectorVal [PolyVal [1,1,0,0,0,0,1,0,0,0,0,1,0,0,1,1],PolyVal [0,0,1,0,0,0,1,0,1,1,1,0,0,0,0,1],PolyVal [0,1,1,1,0,1,1,1,0,0,1,1,1,1,1,0],PolyVal [1,0,1,1,1,0,0,1,0,0,1,1,0,0,1,0]],IndexVal 2], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_p16(vcreate_p16(UINT64_C(0x67a9f068b3ab5d6d)),
                          vcreate_p16(UINT64_C(0x6660808ab42155b0)));
      arg3 = vcreate_p16(UINT64_C(0x4c9d7cee8744c843));
      clear_neon_saturated();
      //  Expect: "result" = 6660808ab42155b07ceef068b3ab5d6d
      result = vcopyq_lane_p16(arg1, 3, arg3, 2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p16(result), 0);
         exp = UINT64_C(0x7ceef068b3ab5d6d);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p16(result), 1);
         exp = UINT64_C(0x6660808ab42155b0);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1810() {

{
   {
      int32x4_t arg1;
      int32x4_t arg3;
      int32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"ins_lane\", fnname = \"vcopyq_laneq_s32\", rettype = \"int32x4_t\", argtypes = \"[int32x4_t,__constrange(0,3) int,int32x4_t,__constrange(0,3) int]\", vals = [VectorVal [IntegerVal 2147450879,IntegerVal 1482751999,IntegerVal (-2147483648),IntegerVal 2147450880],IndexVal 0,VectorVal [IntegerVal (-2033614849),IntegerVal (-2147450880),IntegerVal 0,IntegerVal (-32769)],IndexVal 3], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s32(vcreate_s32(UINT64_C(0x5860ffff7fff7fff)),
                          vcreate_s32(UINT64_C(0x7fff800080000000)));
      arg3 = vcombine_s32(vcreate_s32(UINT64_C(0x8000800086c97fff)),
                          vcreate_s32(UINT64_C(0xffff7fff00000000)));
      clear_neon_saturated();
      //  Expect: "result" = 7fff8000800000005860ffffffff7fff
      result = vcopyq_laneq_s32(arg1, 0, arg3, 3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 0);
         exp = UINT64_C(0x5860ffffffff7fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 1);
         exp = UINT64_C(0x7fff800080000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1811() {

{
   {
      int32x4_t arg1;
      int32x2_t arg3;
      int32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"ins_lane\", fnname = \"vcopyq_lane_s32\", rettype = \"int32x4_t\", argtypes = \"[int32x4_t,__constrange(0,3) int,int32x2_t,__constrange(0,1) int]\", vals = [VectorVal [IntegerVal (-1),IntegerVal (-65536),IntegerVal 2147419376,IntegerVal 2147418112],IndexVal 1,VectorVal [IntegerVal 2147444604,IntegerVal 980156415],IndexVal 1], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s32(vcreate_s32(UINT64_C(0xffff0000ffffffff)),
                          vcreate_s32(UINT64_C(0x7fff00007fff04f0)));
      arg3 = vcreate_s32(UINT64_C(0x3a6bffff7fff677c));
      clear_neon_saturated();
      //  Expect: "result" = 7fff00007fff04f03a6bffffffffffff
      result = vcopyq_lane_s32(arg1, 1, arg3, 1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 0);
         exp = UINT64_C(0x3a6bffffffffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 1);
         exp = UINT64_C(0x7fff00007fff04f0);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1812() {

{
   {
      uint32x4_t arg1;
      uint32x4_t arg3;
      uint32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"ins_lane\", fnname = \"vcopyq_laneq_u32\", rettype = \"uint32x4_t\", argtypes = \"[uint32x4_t,__constrange(0,3) int,uint32x4_t,__constrange(0,3) int]\", vals = [VectorVal [IntegerVal 2147516415,IntegerVal 2147420654,IntegerVal 65535,IntegerVal 19397],IndexVal 0,VectorVal [IntegerVal 2147516415,IntegerVal 2147465872,IntegerVal 3024617471,IntegerVal 469467136],IndexVal 1], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u32(vcreate_u32(UINT64_C(0x7fff09ee80007fff)),
                          vcreate_u32(UINT64_C(0x00004bc50000ffff)));
      arg3 = vcombine_u32(vcreate_u32(UINT64_C(0x7fffba9080007fff)),
                          vcreate_u32(UINT64_C(0x1bfb8000b447ffff)));
      clear_neon_saturated();
      //  Expect: "result" = 00004bc50000ffff7fff09ee7fffba90
      result = vcopyq_laneq_u32(arg1, 0, arg3, 1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 0);
         exp = UINT64_C(0x7fff09ee7fffba90);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 1);
         exp = UINT64_C(0x00004bc50000ffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1813() {

{
   {
      uint32x4_t arg1;
      uint32x2_t arg3;
      uint32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"ins_lane\", fnname = \"vcopyq_lane_u32\", rettype = \"uint32x4_t\", argtypes = \"[uint32x4_t,__constrange(0,3) int,uint32x2_t,__constrange(0,1) int]\", vals = [VectorVal [IntegerVal 37212,IntegerVal 4294934527,IntegerVal 2147549183,IntegerVal 2147450880],IndexVal 0,VectorVal [IntegerVal 4294957237,IntegerVal 2147512215],IndexVal 0], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u32(vcreate_u32(UINT64_C(0xffff7fff0000915c)),
                          vcreate_u32(UINT64_C(0x7fff80008000ffff)));
      arg3 = vcreate_u32(UINT64_C(0x80006f97ffffd8b5));
      clear_neon_saturated();
      //  Expect: "result" = 7fff80008000ffffffff7fffffffd8b5
      result = vcopyq_lane_u32(arg1, 0, arg3, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 0);
         exp = UINT64_C(0xffff7fffffffd8b5);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 1);
         exp = UINT64_C(0x7fff80008000ffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1814() {

{
   {
      float32x4_t arg1;
      float32x4_t arg3;
      float32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"ins_lane\", fnname = \"vcopyq_laneq_f32\", rettype = \"float32x4_t\", argtypes = \"[float32x4_t,__constrange(0,3) int,float32x4_t,__constrange(0,3) int]\", vals = [VectorVal [FloatVal 0.6740370392799377,FloatVal 0.2167622447013855,FloatVal 0.16615110635757446,FloatVal 0.782041072845459],IndexVal 1,VectorVal [FloatVal 0.14365041255950928,FloatVal 0.6814168095588684,FloatVal 3.355288505554199e-2,FloatVal 0.5118576288223267],IndexVal 1], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_f32(vcreate_f32(UINT64_C(0x3e5df6ec3f2c8db1)),
                          vcreate_f32(UINT64_C(0x3f4833d83e2a2384)));
      arg3 = vcombine_f32(vcreate_f32(UINT64_C(0x3f2e71553e131918)),
                          vcreate_f32(UINT64_C(0x3f03091a3d096ec0)));
      clear_neon_saturated();
      //  Expect: "result" = 3f4833d83e2a23843f2e71553f2c8db1
      result = vcopyq_laneq_f32(arg1, 1, arg3, 1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 0);
         exp = ((float32_t) 0.6740370392799377);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 1);
         exp = ((float32_t) 0.6814168095588684);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 2);
         exp = ((float32_t) 0.16615110635757446);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 2 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 3);
         exp = ((float32_t) 0.782041072845459);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 3 ", exp, got);
            }
      }
   }
}
}
void dotests_1815() {

{
   {
      float32x4_t arg1;
      float32x2_t arg3;
      float32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"ins_lane\", fnname = \"vcopyq_lane_f32\", rettype = \"float32x4_t\", argtypes = \"[float32x4_t,__constrange(0,3) int,float32x2_t,__constrange(0,1) int]\", vals = [VectorVal [FloatVal 0.8802317380905151,FloatVal 0.6115453243255615,FloatVal 0.2929879426956177,FloatVal 0.26067662239074707],IndexVal 0,VectorVal [FloatVal 0.9887848496437073,FloatVal 0.1264554262161255],IndexVal 0], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_f32(vcreate_f32(UINT64_C(0x3f1c8e3c3f6156de)),
                          vcreate_f32(UINT64_C(0x3e8577683e960284)));
      arg3 = vcreate_f32(UINT64_C(0x3e017d883f7d2101));
      clear_neon_saturated();
      //  Expect: "result" = 3e8577683e9602843f1c8e3c3f7d2101
      result = vcopyq_lane_f32(arg1, 0, arg3, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 0);
         exp = ((float32_t) 0.9887848496437073);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 1);
         exp = ((float32_t) 0.6115453243255615);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 2);
         exp = ((float32_t) 0.2929879426956177);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 2 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 3);
         exp = ((float32_t) 0.26067662239074707);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 3 ", exp, got);
            }
      }
   }
}
}
void dotests_1816() {

{
   {
      int64x2_t arg1;
      int64x2_t arg3;
      int64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"ins_lane\", fnname = \"vcopyq_laneq_s64\", rettype = \"int64x2_t\", argtypes = \"[int64x2_t,__constrange(0,1) int,int64x2_t,__constrange(0,1) int]\", vals = [VectorVal [IntegerVal (-9223231299366387713),IntegerVal 9223090566173000935],IndexVal 0,VectorVal [IntegerVal 7829930160353771519,IntegerVal 9223231301513876705],IndexVal 0], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s64(vcreate_s64(UINT64_C(0x8000800000007fff)),
                          vcreate_s64(UINT64_C(0x7fff0000ffff84e7)));
      arg3 = vcombine_s64(vcreate_s64(UINT64_C(0x6ca97fff0000ffff)),
                          vcreate_s64(UINT64_C(0x7fff80007fff94e1)));
      clear_neon_saturated();
      //  Expect: "result" = 7fff0000ffff84e76ca97fff0000ffff
      result = vcopyq_laneq_s64(arg1, 0, arg3, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 0);
         exp = UINT64_C(0x6ca97fff0000ffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 1);
         exp = UINT64_C(0x7fff0000ffff84e7);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1817() {

{
   {
      int64x2_t arg1;
      int64x1_t arg3;
      int64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"ins_lane\", fnname = \"vcopyq_lane_s64\", rettype = \"int64x2_t\", argtypes = \"[int64x2_t,__constrange(0,1) int,int64x1_t,__constrange(0,0) int]\", vals = [VectorVal [IntegerVal (-9223231299366453248),IntegerVal 3011078565509736431],IndexVal 0,VectorVal [IntegerVal 281474821226495],IndexVal 0], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s64(vcreate_s64(UINT64_C(0x80007fffffff8000)),
                          vcreate_s64(UINT64_C(0x29c98000800027ef)));
      arg3 = vcreate_s64(UINT64_C(0x0000fffff6bb7fff));
      clear_neon_saturated();
      //  Expect: "result" = 29c98000800027ef0000fffff6bb7fff
      result = vcopyq_lane_s64(arg1, 0, arg3, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 0);
         exp = UINT64_C(0x0000fffff6bb7fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 1);
         exp = UINT64_C(0x29c98000800027ef);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1818() {

{
   {
      uint64x2_t arg1;
      uint64x2_t arg3;
      uint64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"ins_lane\", fnname = \"vcopyq_laneq_u64\", rettype = \"uint64x2_t\", argtypes = \"[uint64x2_t,__constrange(0,1) int,uint64x2_t,__constrange(0,1) int]\", vals = [VectorVal [IntegerVal 7385814946920999100,IntegerVal 281474976677887],IndexVal 0,VectorVal [IntegerVal 9223233738907877376,IntegerVal 18446603338368647167],IndexVal 0], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u64(vcreate_u64(UINT64_C(0x667faf8fffff28bc)),
                          vcreate_u64(UINT64_C(0x0000ffffffff7fff)));
      arg3 = vcombine_u64(vcreate_u64(UINT64_C(0x7fff823800008000)),
                          vcreate_u64(UINT64_C(0xffff80007fff7fff)));
      clear_neon_saturated();
      //  Expect: "result" = 0000ffffffff7fff7fff823800008000
      result = vcopyq_laneq_u64(arg1, 0, arg3, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 0);
         exp = UINT64_C(0x7fff823800008000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 1);
         exp = UINT64_C(0x0000ffffffff7fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1819() {

{
   {
      uint64x2_t arg1;
      uint64x1_t arg3;
      uint64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"ins_lane\", fnname = \"vcopyq_lane_u64\", rettype = \"uint64x2_t\", argtypes = \"[uint64x2_t,__constrange(0,1) int,uint64x1_t,__constrange(0,0) int]\", vals = [VectorVal [IntegerVal 281474976648652,IntegerVal 18446744071562129760],IndexVal 0,VectorVal [IntegerVal 3897584004659904512],IndexVal 0], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u64(vcreate_u64(UINT64_C(0x0000ffffffff0dcc)),
                          vcreate_u64(UINT64_C(0xffffffff8000f160)));
      arg3 = vcreate_u64(UINT64_C(0x361700007fff8000));
      clear_neon_saturated();
      //  Expect: "result" = ffffffff8000f160361700007fff8000
      result = vcopyq_lane_u64(arg1, 0, arg3, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 0);
         exp = UINT64_C(0x361700007fff8000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 1);
         exp = UINT64_C(0xffffffff8000f160);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1820() {

{
   {
      float64x2_t arg1;
      float64x2_t arg3;
      float64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"ins_lane\", fnname = \"vcopyq_laneq_f64\", rettype = \"float64x2_t\", argtypes = \"[float64x2_t,__constrange(0,1) int,float64x2_t,__constrange(0,1) int]\", vals = [VectorVal [FloatVal 0.7417450814308824,FloatVal 0.11795718338051153],IndexVal 1,VectorVal [FloatVal 3.5205911543064294e-2,FloatVal 0.11859938352701949],IndexVal 0], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_f64(vcreate_f64(UINT64_C(0x3fe7bc602e56dd28)),
                          vcreate_f64(UINT64_C(0x3fbe327124f29410)));
      arg3 = vcombine_f64(vcreate_f64(UINT64_C(0x3fa206825d681ae0)),
                          vcreate_f64(UINT64_C(0x3fbe5c87799305f8)));
      clear_neon_saturated();
      //  Expect: "result" = 3fa206825d681ae03fe7bc602e56dd28
      result = vcopyq_laneq_f64(arg1, 1, arg3, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float64_t got;
         float64_t exp;
         got = vgetq_lane_f64(result, 0);
         exp = 0.7417450814308824;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float64_t got;
         float64_t exp;
         got = vgetq_lane_f64(result, 1);
         exp = 3.5205911543064294e-2;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
   }
}
}
void dotests_1821() {

{
   {
      float64x2_t arg1;
      float64x1_t arg3;
      float64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"ins_lane\", fnname = \"vcopyq_lane_f64\", rettype = \"float64x2_t\", argtypes = \"[float64x2_t,__constrange(0,1) int,float64x1_t,__constrange(0,0) int]\", vals = [VectorVal [FloatVal 0.2388386474894234,FloatVal 0.8826076934118895],IndexVal 1,VectorVal [FloatVal 0.7896522182826664],IndexVal 0], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_f64(vcreate_f64(UINT64_C(0x3fce9243c9fe7504)),
                          vcreate_f64(UINT64_C(0x3fec3e527d4cddad)));
      arg3 = vcreate_f64(UINT64_C(0x3fe944d4ba979cec));
      clear_neon_saturated();
      //  Expect: "result" = 3fe944d4ba979cec3fce9243c9fe7504
      result = vcopyq_lane_f64(arg1, 1, arg3, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float64_t got;
         float64_t exp;
         got = vgetq_lane_f64(result, 0);
         exp = 0.2388386474894234;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float64_t got;
         float64_t exp;
         got = vgetq_lane_f64(result, 1);
         exp = 0.7896522182826664;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
   }
}
}
void dotests_1822() {

{
   {
      poly64x2_t arg1;
      poly64x2_t arg3;
      poly64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"ins_lane\", fnname = \"vcopyq_laneq_p64\", rettype = \"poly64x2_t\", argtypes = \"[poly64x2_t,__constrange(0,1) int,poly64x2_t,__constrange(0,1) int]\", vals = [VectorVal [PolyVal [1,0,0,1,0,0,1,1,1,0,1,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,1,1,0,0,0,1,1,1,0,1,0,0,0,1,1,1,1,0,1,1,0,0,1,0,1,0,1,1,0,1,1,0,1,0,0],PolyVal [1,1,0,1,0,1,1,1,0,0,0,0,0,0,0,0,0,1,0,1,0,1,1,1,1,0,1,0,0,1,0,0,1,0,1,1,0,1,1,0,1,0,0,0,0,1,0,0,1,1,1,0,0,0,1,0,0,0,0,0,1,0,0,1]],IndexVal 1,VectorVal [PolyVal [1,0,1,0,1,1,0,0,0,0,0,0,0,1,0,1,1,0,1,1,1,1,0,0,1,0,1,1,1,0,1,1,1,0,0,1,0,1,0,0,1,0,1,0,0,1,1,1,1,0,1,1,0,0,0,1,1,0,1,1,1,1,1,1],PolyVal [1,1,0,1,0,0,1,1,0,1,1,0,0,1,0,0,1,1,0,0,0,1,0,0,1,1,0,1,0,1,1,1,1,1,0,1,0,0,0,0,1,0,0,0,0,0,1,1,1,0,1,1,1,0,0,1,1,1,0,0,1,1,0,1]],IndexVal 1], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_p64(vcreate_p64(UINT64_C(0x2da9bc5c740075c9)),
                          vcreate_p64(UINT64_C(0x9047216d25ea00eb)));
      arg3 = vcombine_p64(vcreate_p64(UINT64_C(0xfd8de529dd3da035)),
                          vcreate_p64(UINT64_C(0xb39dc10beb2326cb)));
      clear_neon_saturated();
      //  Expect: "result" = b39dc10beb2326cb2da9bc5c740075c9
      result = vcopyq_laneq_p64(arg1, 1, arg3, 1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p64(result), 0);
         exp = UINT64_C(0x2da9bc5c740075c9);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p64(result), 1);
         exp = UINT64_C(0xb39dc10beb2326cb);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1823() {

{
   {
      poly64x2_t arg1;
      poly64x1_t arg3;
      poly64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"ins_lane\", fnname = \"vcopyq_lane_p64\", rettype = \"poly64x2_t\", argtypes = \"[poly64x2_t,__constrange(0,1) int,poly64x1_t,__constrange(0,0) int]\", vals = [VectorVal [PolyVal [1,1,1,1,0,0,0,1,0,0,1,0,0,1,0,1,0,0,0,1,1,0,1,0,1,1,1,0,1,1,1,0,0,0,0,1,0,1,0,0,0,0,1,0,0,1,1,1,0,0,1,0,0,1,0,1,1,1,0,1,0,0,0,0],PolyVal [1,0,0,1,1,0,1,1,0,1,1,1,0,0,0,1,1,1,0,0,0,0,0,1,1,0,0,1,0,0,1,1,0,0,1,1,1,1,1,1,0,0,0,1,1,0,0,1,1,0,1,0,1,0,0,1,0,0,0,0,0,1,0,1]],IndexVal 0,VectorVal [PolyVal [1,0,1,1,0,0,0,1,1,1,1,1,1,0,1,1,0,0,1,1,1,1,1,1,0,0,1,0,1,1,1,1,1,1,1,0,0,0,0,0,1,0,1,0,1,0,0,0,1,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0]],IndexVal 0], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_p64(vcreate_p64(UINT64_C(0x0ba4e4287758a48f)),
                          vcreate_p64(UINT64_C(0xa09598fcc9838ed9)));
      arg3 = vcreate_p64(UINT64_C(0x044b1507f4fcdf8d));
      clear_neon_saturated();
      //  Expect: "result" = a09598fcc9838ed9044b1507f4fcdf8d
      result = vcopyq_lane_p64(arg1, 0, arg3, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p64(result), 0);
         exp = UINT64_C(0x044b1507f4fcdf8d);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p64(result), 1);
         exp = UINT64_C(0xa09598fcc9838ed9);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1824() {

{
   {
      int8x8_t arg1;
      int8x16_t arg3;
      int8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"ins_lane\", fnname = \"vcopy_laneq_s8\", rettype = \"int8x8_t\", argtypes = \"[int8x8_t,__constrange(0,7) int,int8x16_t,__constrange(0,15) int]\", vals = [VectorVal [IntegerVal (-1),IntegerVal (-1),IntegerVal (-68),IntegerVal 29,IntegerVal 0,IntegerVal (-1),IntegerVal (-1),IntegerVal (-1)],IndexVal 0,VectorVal [IntegerVal (-128),IntegerVal (-128),IntegerVal (-1),IntegerVal 127,IntegerVal (-128),IntegerVal (-128),IntegerVal 127,IntegerVal (-1),IntegerVal (-1),IntegerVal (-128),IntegerVal 127,IntegerVal 127,IntegerVal 19,IntegerVal 127,IntegerVal (-1),IntegerVal (-1)],IndexVal 7], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s8(UINT64_C(0xffffff001dbcffff));
      arg3 = vcombine_s8(vcreate_s8(UINT64_C(0xff7f80807fff8080)),
                         vcreate_s8(UINT64_C(0xffff7f137f7f80ff)));
      clear_neon_saturated();
      //  Expect: "result" = ffffff001dbcffff
      result = vcopy_laneq_s8(arg1, 0, arg3, 7);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s8(result), 0);
      exp = UINT64_C(0xffffff001dbcffff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1825() {

{
   {
      int8x8_t arg1;
      int8x8_t arg3;
      int8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"ins_lane\", fnname = \"vcopy_lane_s8\", rettype = \"int8x8_t\", argtypes = \"[int8x8_t,__constrange(0,7) int,int8x8_t,__constrange(0,7) int]\", vals = [VectorVal [IntegerVal 0,IntegerVal 127,IntegerVal 127,IntegerVal 127,IntegerVal 32,IntegerVal 85,IntegerVal 0,IntegerVal (-1)],IndexVal 6,VectorVal [IntegerVal 0,IntegerVal 39,IntegerVal 0,IntegerVal (-1),IntegerVal (-128),IntegerVal 0,IntegerVal 0,IntegerVal (-128)],IndexVal 6], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s8(UINT64_C(0xff0055207f7f7f00));
      arg3 = vcreate_s8(UINT64_C(0x80000080ff002700));
      clear_neon_saturated();
      //  Expect: "result" = ff0055207f7f7f00
      result = vcopy_lane_s8(arg1, 6, arg3, 6);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s8(result), 0);
      exp = UINT64_C(0xff0055207f7f7f00);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1826() {

{
   {
      uint8x8_t arg1;
      uint8x16_t arg3;
      uint8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"ins_lane\", fnname = \"vcopy_laneq_u8\", rettype = \"uint8x8_t\", argtypes = \"[uint8x8_t,__constrange(0,7) int,uint8x16_t,__constrange(0,15) int]\", vals = [VectorVal [IntegerVal 128,IntegerVal 127,IntegerVal 255,IntegerVal 0,IntegerVal 195,IntegerVal 128,IntegerVal 127,IntegerVal 0],IndexVal 2,VectorVal [IntegerVal 0,IntegerVal 0,IntegerVal 255,IntegerVal 127,IntegerVal 186,IntegerVal 127,IntegerVal 127,IntegerVal 159,IntegerVal 127,IntegerVal 16,IntegerVal 127,IntegerVal 127,IntegerVal 32,IntegerVal 255,IntegerVal 128,IntegerVal 128],IndexVal 1], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u8(UINT64_C(0x007f80c300ff7f80));
      arg3 = vcombine_u8(vcreate_u8(UINT64_C(0x9f7f7fba7fff0000)),
                         vcreate_u8(UINT64_C(0x8080ff207f7f107f)));
      clear_neon_saturated();
      //  Expect: "result" = 007f80c300007f80
      result = vcopy_laneq_u8(arg1, 2, arg3, 1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u8(result), 0);
      exp = UINT64_C(0x007f80c300007f80);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1827() {

{
   {
      uint8x8_t arg1;
      uint8x8_t arg3;
      uint8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"ins_lane\", fnname = \"vcopy_lane_u8\", rettype = \"uint8x8_t\", argtypes = \"[uint8x8_t,__constrange(0,7) int,uint8x8_t,__constrange(0,7) int]\", vals = [VectorVal [IntegerVal 128,IntegerVal 0,IntegerVal 127,IntegerVal 127,IntegerVal 7,IntegerVal 0,IntegerVal 0,IntegerVal 255],IndexVal 0,VectorVal [IntegerVal 0,IntegerVal 255,IntegerVal 0,IntegerVal 123,IntegerVal 128,IntegerVal 153,IntegerVal 255,IntegerVal 255],IndexVal 5], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u8(UINT64_C(0xff0000077f7f0080));
      arg3 = vcreate_u8(UINT64_C(0xffff99807b00ff00));
      clear_neon_saturated();
      //  Expect: "result" = ff0000077f7f0099
      result = vcopy_lane_u8(arg1, 0, arg3, 5);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u8(result), 0);
      exp = UINT64_C(0xff0000077f7f0099);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1828() {

{
   {
      poly8x8_t arg1;
      poly8x16_t arg3;
      poly8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"ins_lane\", fnname = \"vcopy_laneq_p8\", rettype = \"poly8x8_t\", argtypes = \"[poly8x8_t,__constrange(0,7) int,poly8x16_t,__constrange(0,15) int]\", vals = [VectorVal [PolyVal [0,1,0,0,1,0,1,1],PolyVal [0,0,1,0,0,0,0,1],PolyVal [0,1,1,0,0,0,0,1],PolyVal [0,1,0,1,0,0,1,1],PolyVal [0,0,1,0,0,0,1,1],PolyVal [1,1,1,0,0,0,0,0],PolyVal [1,1,1,0,1,0,0,1],PolyVal [1,1,0,0,0,1,0,1]],IndexVal 1,VectorVal [PolyVal [0,1,1,1,1,0,0,1],PolyVal [1,1,0,1,1,1,0,0],PolyVal [0,1,1,0,0,0,1,1],PolyVal [0,0,0,1,1,0,0,1],PolyVal [1,0,1,0,1,1,1,0],PolyVal [0,0,0,0,1,0,1,0],PolyVal [0,1,0,0,1,1,1,0],PolyVal [1,0,1,1,1,0,1,0],PolyVal [1,1,0,1,1,0,0,1],PolyVal [0,1,1,0,0,1,1,0],PolyVal [0,1,1,0,0,0,0,1],PolyVal [1,0,0,1,0,0,1,1],PolyVal [0,1,0,0,0,0,1,0],PolyVal [1,0,0,0,0,1,0,1],PolyVal [1,1,0,0,0,0,1,0],PolyVal [1,1,0,1,1,1,0,1]],IndexVal 1], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_p8(UINT64_C(0xa39707c4ca8684d2));
      arg3 = vcombine_p8(vcreate_p8(UINT64_C(0x5d72507598c63b9e)),
                         vcreate_p8(UINT64_C(0xbb43a142c986669b)));
      clear_neon_saturated();
      //  Expect: "result" = a39707c4ca863bd2
      result = vcopy_laneq_p8(arg1, 1, arg3, 1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_p8(result), 0);
      exp = UINT64_C(0xa39707c4ca863bd2);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1829() {

{
   {
      poly8x8_t arg1;
      poly8x8_t arg3;
      poly8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"ins_lane\", fnname = \"vcopy_lane_p8\", rettype = \"poly8x8_t\", argtypes = \"[poly8x8_t,__constrange(0,7) int,poly8x8_t,__constrange(0,7) int]\", vals = [VectorVal [PolyVal [1,1,0,1,0,1,1,1],PolyVal [1,0,1,1,1,0,1,1],PolyVal [1,0,0,0,1,1,1,1],PolyVal [0,1,0,1,1,1,1,0],PolyVal [1,1,1,0,1,1,0,0],PolyVal [1,1,1,1,0,0,0,0],PolyVal [1,1,0,0,0,0,1,1],PolyVal [1,0,1,1,0,0,1,1]],IndexVal 0,VectorVal [PolyVal [0,1,0,1,1,1,0,1],PolyVal [1,0,1,1,1,1,1,0],PolyVal [1,1,1,0,0,0,0,1],PolyVal [0,0,1,0,0,0,1,0],PolyVal [1,0,0,0,0,0,1,1],PolyVal [0,0,1,1,0,0,1,1],PolyVal [0,1,1,0,0,1,1,0],PolyVal [0,0,1,1,0,0,1,0]],IndexVal 0], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_p8(UINT64_C(0xcdc30f377af1ddeb));
      arg3 = vcreate_p8(UINT64_C(0x4c66ccc144877dba));
      clear_neon_saturated();
      //  Expect: "result" = cdc30f377af1ddba
      result = vcopy_lane_p8(arg1, 0, arg3, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_p8(result), 0);
      exp = UINT64_C(0xcdc30f377af1ddba);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1830() {

{
   {
      int16x4_t arg1;
      int16x8_t arg3;
      int16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"ins_lane\", fnname = \"vcopy_laneq_s16\", rettype = \"int16x4_t\", argtypes = \"[int16x4_t,__constrange(0,3) int,int16x8_t,__constrange(0,7) int]\", vals = [VectorVal [IntegerVal 0,IntegerVal 32767,IntegerVal 32767,IntegerVal (-1)],IndexVal 0,VectorVal [IntegerVal 32767,IntegerVal (-1),IntegerVal (-32768),IntegerVal (-32768),IntegerVal 32767,IntegerVal (-1),IntegerVal 0,IntegerVal (-32768)],IndexVal 0], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s16(UINT64_C(0xffff7fff7fff0000));
      arg3 = vcombine_s16(vcreate_s16(UINT64_C(0x80008000ffff7fff)),
                          vcreate_s16(UINT64_C(0x80000000ffff7fff)));
      clear_neon_saturated();
      //  Expect: "result" = ffff7fff7fff7fff
      result = vcopy_laneq_s16(arg1, 0, arg3, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s16(result), 0);
      exp = UINT64_C(0xffff7fff7fff7fff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1831() {

{
   {
      int16x4_t arg1;
      int16x4_t arg3;
      int16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"ins_lane\", fnname = \"vcopy_lane_s16\", rettype = \"int16x4_t\", argtypes = \"[int16x4_t,__constrange(0,3) int,int16x4_t,__constrange(0,3) int]\", vals = [VectorVal [IntegerVal 0,IntegerVal 0,IntegerVal 0,IntegerVal 32767],IndexVal 1,VectorVal [IntegerVal 32767,IntegerVal (-15003),IntegerVal 0,IntegerVal (-32768)],IndexVal 0], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s16(UINT64_C(0x7fff000000000000));
      arg3 = vcreate_s16(UINT64_C(0x80000000c5657fff));
      clear_neon_saturated();
      //  Expect: "result" = 7fff00007fff0000
      result = vcopy_lane_s16(arg1, 1, arg3, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s16(result), 0);
      exp = UINT64_C(0x7fff00007fff0000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1832() {

{
   {
      uint16x4_t arg1;
      uint16x8_t arg3;
      uint16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"ins_lane\", fnname = \"vcopy_laneq_u16\", rettype = \"uint16x4_t\", argtypes = \"[uint16x4_t,__constrange(0,3) int,uint16x8_t,__constrange(0,7) int]\", vals = [VectorVal [IntegerVal 65535,IntegerVal 32767,IntegerVal 0,IntegerVal 32768],IndexVal 1,VectorVal [IntegerVal 51717,IntegerVal 22772,IntegerVal 65535,IntegerVal 32767,IntegerVal 32767,IntegerVal 13870,IntegerVal 26114,IntegerVal 0],IndexVal 4], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u16(UINT64_C(0x800000007fffffff));
      arg3 = vcombine_u16(vcreate_u16(UINT64_C(0x7fffffff58f4ca05)),
                          vcreate_u16(UINT64_C(0x00006602362e7fff)));
      clear_neon_saturated();
      //  Expect: "result" = 800000007fffffff
      result = vcopy_laneq_u16(arg1, 1, arg3, 4);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u16(result), 0);
      exp = UINT64_C(0x800000007fffffff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1833() {

{
   {
      uint16x4_t arg1;
      uint16x4_t arg3;
      uint16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"ins_lane\", fnname = \"vcopy_lane_u16\", rettype = \"uint16x4_t\", argtypes = \"[uint16x4_t,__constrange(0,3) int,uint16x4_t,__constrange(0,3) int]\", vals = [VectorVal [IntegerVal 32767,IntegerVal 46223,IntegerVal 32768,IntegerVal 5628],IndexVal 2,VectorVal [IntegerVal 0,IntegerVal 0,IntegerVal 32767,IntegerVal 65535],IndexVal 2], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u16(UINT64_C(0x15fc8000b48f7fff));
      arg3 = vcreate_u16(UINT64_C(0xffff7fff00000000));
      clear_neon_saturated();
      //  Expect: "result" = 15fc7fffb48f7fff
      result = vcopy_lane_u16(arg1, 2, arg3, 2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u16(result), 0);
      exp = UINT64_C(0x15fc7fffb48f7fff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1834() {

{
   {
      poly16x4_t arg1;
      poly16x8_t arg3;
      poly16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"ins_lane\", fnname = \"vcopy_laneq_p16\", rettype = \"poly16x4_t\", argtypes = \"[poly16x4_t,__constrange(0,3) int,poly16x8_t,__constrange(0,7) int]\", vals = [VectorVal [PolyVal [0,0,1,0,0,1,0,1,1,1,0,1,0,0,0,0],PolyVal [0,1,1,0,1,1,1,0,0,0,1,0,0,1,1,1],PolyVal [1,1,0,1,1,1,0,0,0,0,0,1,1,0,0,1],PolyVal [0,1,0,1,0,0,1,0,0,0,0,1,1,1,1,0]],IndexVal 2,VectorVal [PolyVal [0,1,1,0,0,1,1,0,0,0,0,1,0,1,0,0],PolyVal [1,1,0,0,1,1,1,1,1,0,1,1,0,0,1,1],PolyVal [0,0,0,0,0,1,1,0,0,1,0,0,1,0,1,1],PolyVal [0,1,0,1,0,1,1,1,1,0,0,1,0,0,0,1],PolyVal [0,0,0,1,0,1,1,0,0,0,0,1,0,1,0,0],PolyVal [0,0,1,1,1,0,0,1,1,1,1,1,0,1,0,0],PolyVal [1,0,0,0,1,0,0,0,1,0,1,0,0,0,1,0],PolyVal [0,0,1,0,1,0,0,0,1,1,1,0,0,0,1,1]],IndexVal 3], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_p16(UINT64_C(0x784a983be4760ba4));
      arg3 = vcombine_p16(vcreate_p16(UINT64_C(0x89ead260cdf32866)),
                          vcreate_p16(UINT64_C(0xc71445112f9c2868)));
      clear_neon_saturated();
      //  Expect: "result" = 784a89eae4760ba4
      result = vcopy_laneq_p16(arg1, 2, arg3, 3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_p16(result), 0);
      exp = UINT64_C(0x784a89eae4760ba4);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1835() {

{
   {
      poly16x4_t arg1;
      poly16x4_t arg3;
      poly16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"ins_lane\", fnname = \"vcopy_lane_p16\", rettype = \"poly16x4_t\", argtypes = \"[poly16x4_t,__constrange(0,3) int,poly16x4_t,__constrange(0,3) int]\", vals = [VectorVal [PolyVal [1,1,1,0,1,0,1,1,0,1,1,0,1,1,1,0],PolyVal [1,1,1,0,1,0,1,0,1,1,0,1,1,0,0,0],PolyVal [0,0,0,0,1,1,0,1,0,1,0,1,1,1,0,1],PolyVal [0,1,1,1,0,1,0,0,1,0,0,0,0,0,0,1]],IndexVal 1,VectorVal [PolyVal [1,1,0,0,1,0,0,0,0,0,0,0,0,0,1,1],PolyVal [1,0,1,1,1,1,0,0,0,0,1,0,0,1,1,0],PolyVal [0,1,1,1,0,0,1,1,1,0,0,1,1,1,1,1],PolyVal [0,1,1,1,1,0,0,0,1,0,1,1,0,0,0,0]],IndexVal 3], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_p16(UINT64_C(0x812ebab01b5776d7));
      arg3 = vcreate_p16(UINT64_C(0x0d1ef9ce643dc013));
      clear_neon_saturated();
      //  Expect: "result" = 812ebab00d1e76d7
      result = vcopy_lane_p16(arg1, 1, arg3, 3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_p16(result), 0);
      exp = UINT64_C(0x812ebab00d1e76d7);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1836() {

{
   {
      int32x2_t arg1;
      int32x4_t arg3;
      int32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"ins_lane\", fnname = \"vcopy_laneq_s32\", rettype = \"int32x2_t\", argtypes = \"[int32x2_t,__constrange(0,1) int,int32x4_t,__constrange(0,3) int]\", vals = [VectorVal [IntegerVal 32768,IntegerVal (-32768)],IndexVal 1,VectorVal [IntegerVal (-32768),IntegerVal 32767,IntegerVal (-1890025473),IntegerVal (-1846738945)],IndexVal 1], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s32(UINT64_C(0xffff800000008000));
      arg3 = vcombine_s32(vcreate_s32(UINT64_C(0x00007fffffff8000)),
                          vcreate_s32(UINT64_C(0x91ecffff8f587fff)));
      clear_neon_saturated();
      //  Expect: "result" = 00007fff00008000
      result = vcopy_laneq_s32(arg1, 1, arg3, 1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s32(result), 0);
      exp = UINT64_C(0x00007fff00008000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1837() {

{
   {
      int32x2_t arg1;
      int32x2_t arg3;
      int32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"ins_lane\", fnname = \"vcopy_lane_s32\", rettype = \"int32x2_t\", argtypes = \"[int32x2_t,__constrange(0,1) int,int32x2_t,__constrange(0,1) int]\", vals = [VectorVal [IntegerVal (-32769),IntegerVal (-2147450881)],IndexVal 0,VectorVal [IntegerVal 32767,IntegerVal (-220818091)],IndexVal 1], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s32(UINT64_C(0x80007fffffff7fff));
      arg3 = vcreate_s32(UINT64_C(0xf2d6955500007fff));
      clear_neon_saturated();
      //  Expect: "result" = 80007ffff2d69555
      result = vcopy_lane_s32(arg1, 0, arg3, 1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s32(result), 0);
      exp = UINT64_C(0x80007ffff2d69555);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1838() {

{
   {
      uint32x2_t arg1;
      uint32x4_t arg3;
      uint32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"ins_lane\", fnname = \"vcopy_laneq_u32\", rettype = \"uint32x2_t\", argtypes = \"[uint32x2_t,__constrange(0,1) int,uint32x4_t,__constrange(0,3) int]\", vals = [VectorVal [IntegerVal 47027,IntegerVal 2147450880],IndexVal 0,VectorVal [IntegerVal 4294934528,IntegerVal 2304376832,IntegerVal 4243062784,IntegerVal 2147450880],IndexVal 0], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u32(UINT64_C(0x7fff80000000b7b3));
      arg3 = vcombine_u32(vcreate_u32(UINT64_C(0x895a0000ffff8000)),
                          vcreate_u32(UINT64_C(0x7fff8000fce80000)));
      clear_neon_saturated();
      //  Expect: "result" = 7fff8000ffff8000
      result = vcopy_laneq_u32(arg1, 0, arg3, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u32(result), 0);
      exp = UINT64_C(0x7fff8000ffff8000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1839() {

{
   {
      uint32x2_t arg1;
      uint32x2_t arg3;
      uint32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"ins_lane\", fnname = \"vcopy_lane_u32\", rettype = \"uint32x2_t\", argtypes = \"[uint32x2_t,__constrange(0,1) int,uint32x2_t,__constrange(0,1) int]\", vals = [VectorVal [IntegerVal 2147450879,IntegerVal 1642031982],IndexVal 0,VectorVal [IntegerVal 2147483647,IntegerVal 2147548291],IndexVal 0], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u32(UINT64_C(0x61df6b6e7fff7fff));
      arg3 = vcreate_u32(UINT64_C(0x8000fc837fffffff));
      clear_neon_saturated();
      //  Expect: "result" = 61df6b6e7fffffff
      result = vcopy_lane_u32(arg1, 0, arg3, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u32(result), 0);
      exp = UINT64_C(0x61df6b6e7fffffff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1840() {

{
   {
      float32x2_t arg1;
      float32x4_t arg3;
      float32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"ins_lane\", fnname = \"vcopy_laneq_f32\", rettype = \"float32x2_t\", argtypes = \"[float32x2_t,__constrange(0,1) int,float32x4_t,__constrange(0,3) int]\", vals = [VectorVal [FloatVal 0.28089290857315063,FloatVal 0.7020221948623657],IndexVal 0,VectorVal [FloatVal 0.19461864233016968,FloatVal 0.7517934441566467,FloatVal 0.24043357372283936,FloatVal 0.19720977544784546],IndexVal 3], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_f32(UINT64_C(0x3f33b7ba3e8fd132));
      arg3 = vcombine_f32(vcreate_f32(UINT64_C(0x3f4075893e474a1c)),
                          vcreate_f32(UINT64_C(0x3e49f15c3e763438)));
      clear_neon_saturated();
      //  Expect: "result" = 3f33b7ba3e49f15c
      result = vcopy_laneq_f32(arg1, 0, arg3, 3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result, 0);
         exp = ((float32_t) 0.19720977544784546);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result, 1);
         exp = ((float32_t) 0.7020221948623657);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
   }
}
}
void dotests_1841() {

{
   {
      float32x2_t arg1;
      float32x2_t arg3;
      float32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"ins_lane\", fnname = \"vcopy_lane_f32\", rettype = \"float32x2_t\", argtypes = \"[float32x2_t,__constrange(0,1) int,float32x2_t,__constrange(0,1) int]\", vals = [VectorVal [FloatVal 0.6391105055809021,FloatVal 0.5515443682670593],IndexVal 1,VectorVal [FloatVal 0.13081854581832886,FloatVal 0.5652832388877869],IndexVal 0], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_f32(UINT64_C(0x3f0d32033f239cbf));
      arg3 = vcreate_f32(UINT64_C(0x3f10b6673e05f54c));
      clear_neon_saturated();
      //  Expect: "result" = 3e05f54c3f239cbf
      result = vcopy_lane_f32(arg1, 1, arg3, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result, 0);
         exp = ((float32_t) 0.6391105055809021);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result, 1);
         exp = ((float32_t) 0.13081854581832886);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
   }
}
}
void dotests_1842() {

{
   {
      int64x1_t arg1;
      int64x2_t arg3;
      int64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"ins_lane\", fnname = \"vcopy_laneq_s64\", rettype = \"int64x1_t\", argtypes = \"[int64x1_t,__constrange(0,0) int,int64x2_t,__constrange(0,1) int]\", vals = [VectorVal [IntegerVal (-4588226249926705152)],IndexVal 0,VectorVal [IntegerVal 9223231301513969663,IntegerVal (-9223231298381807617)],IndexVal 0], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s64(UINT64_C(0xc0535888ffff0000));
      arg3 = vcombine_s64(vcreate_s64(UINT64_C(0x7fff80008000ffff)),
                          vcreate_s64(UINT64_C(0x800080003aafffff)));
      clear_neon_saturated();
      //  Expect: "result" = 7fff80008000ffff
      result = vcopy_laneq_s64(arg1, 0, arg3, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s64(result), 0);
      exp = UINT64_C(0x7fff80008000ffff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1843() {

{
   {
      int64x1_t arg1;
      int64x1_t arg3;
      int64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"ins_lane\", fnname = \"vcopy_lane_s64\", rettype = \"int64x1_t\", argtypes = \"[int64x1_t,__constrange(0,0) int,int64x1_t,__constrange(0,0) int]\", vals = [VectorVal [IntegerVal 5097934037915080072],IndexVal 0,VectorVal [IntegerVal (-5902671001258262528)],IndexVal 0], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s64(UINT64_C(0x46bf7fff5a4d1588));
      arg3 = vcreate_s64(UINT64_C(0xae157fff80008000));
      clear_neon_saturated();
      //  Expect: "result" = ae157fff80008000
      result = vcopy_lane_s64(arg1, 0, arg3, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s64(result), 0);
      exp = UINT64_C(0xae157fff80008000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1844() {

{
   {
      uint64x1_t arg1;
      uint64x2_t arg3;
      uint64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"ins_lane\", fnname = \"vcopy_laneq_u64\", rettype = \"uint64x1_t\", argtypes = \"[uint64x1_t,__constrange(0,0) int,uint64x2_t,__constrange(0,1) int]\", vals = [VectorVal [IntegerVal 18446603331926253664],IndexVal 0,VectorVal [IntegerVal 1892074793449021055,IntegerVal 2147516416],IndexVal 0], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u64(UINT64_C(0xffff7fff00006060));
      arg3 = vcombine_u64(vcreate_u64(UINT64_C(0x1a41ffffffffde7f)),
                          vcreate_u64(UINT64_C(0x0000000080008000)));
      clear_neon_saturated();
      //  Expect: "result" = 1a41ffffffffde7f
      result = vcopy_laneq_u64(arg1, 0, arg3, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(result, 0);
      exp = UINT64_C(0x1a41ffffffffde7f);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1845() {

{
   {
      uint64x1_t arg1;
      uint64x1_t arg3;
      uint64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"ins_lane\", fnname = \"vcopy_lane_u64\", rettype = \"uint64x1_t\", argtypes = \"[uint64x1_t,__constrange(0,0) int,uint64x1_t,__constrange(0,0) int]\", vals = [VectorVal [IntegerVal 140740003266559],IndexVal 0,VectorVal [IntegerVal 18446601762115747839],IndexVal 0], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u64(UINT64_C(0x0000800095e67fff));
      arg3 = vcreate_u64(UINT64_C(0xffff7e918000ffff));
      clear_neon_saturated();
      //  Expect: "result" = ffff7e918000ffff
      result = vcopy_lane_u64(arg1, 0, arg3, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(result, 0);
      exp = UINT64_C(0xffff7e918000ffff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1846() {

{
   {
      float64x1_t arg1;
      float64x2_t arg3;
      float64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"ins_lane\", fnname = \"vcopy_laneq_f64\", rettype = \"float64x1_t\", argtypes = \"[float64x1_t,__constrange(0,0) int,float64x2_t,__constrange(0,1) int]\", vals = [VectorVal [FloatVal 3.693250286346261e-2],IndexVal 0,VectorVal [FloatVal 0.1480195926876805,FloatVal 0.39498647219724015],IndexVal 1], start_saturated = False}";
      int reported = 0;
      float64_t got;
      float64_t exp;
      arg1 = vcreate_f64(UINT64_C(0x3fa2e8d127ea7ec0));
      arg3 = vcombine_f64(vcreate_f64(UINT64_C(0x3fc2f24e56e162d4)),
                          vcreate_f64(UINT64_C(0x3fd94775571cc596)));
      clear_neon_saturated();
      //  Expect: "result" = 3fd94775571cc596
      result = vcopy_laneq_f64(arg1, 0, arg3, 1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_f64(result, 0);
      exp = 0.39498647219724015;
      if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
         }
   }
}
}
void dotests_1847() {

{
   {
      float64x1_t arg1;
      float64x1_t arg3;
      float64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"ins_lane\", fnname = \"vcopy_lane_f64\", rettype = \"float64x1_t\", argtypes = \"[float64x1_t,__constrange(0,0) int,float64x1_t,__constrange(0,0) int]\", vals = [VectorVal [FloatVal 0.8467452697623652],IndexVal 0,VectorVal [FloatVal 0.6458895144887211],IndexVal 0], start_saturated = False}";
      int reported = 0;
      float64_t got;
      float64_t exp;
      arg1 = vcreate_f64(UINT64_C(0x3feb18898935817c));
      arg3 = vcreate_f64(UINT64_C(0x3fe4ab207cb1de36));
      clear_neon_saturated();
      //  Expect: "result" = 3fe4ab207cb1de36
      result = vcopy_lane_f64(arg1, 0, arg3, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_f64(result, 0);
      exp = 0.6458895144887211;
      if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
         }
   }
}
}
void dotests_1848() {

{
   {
      poly64x1_t arg1;
      poly64x2_t arg3;
      poly64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"ins_lane\", fnname = \"vcopy_laneq_p64\", rettype = \"poly64x1_t\", argtypes = \"[poly64x1_t,__constrange(0,0) int,poly64x2_t,__constrange(0,1) int]\", vals = [VectorVal [PolyVal [1,1,0,1,0,0,0,0,1,0,0,1,0,1,0,1,1,0,1,1,1,1,0,1,1,0,1,1,1,0,0,0,1,1,0,1,1,0,0,0,1,1,1,0,0,0,0,1,0,0,0,0,1,1,0,1,0,0,1,1,1,1,1,0]],IndexVal 0,VectorVal [PolyVal [0,0,1,1,0,0,0,0,0,1,0,0,0,1,0,1,0,1,0,1,1,0,0,1,1,1,0,0,0,1,0,1,0,0,0,0,0,1,0,1,0,1,0,1,0,1,1,0,0,0,1,1,0,0,1,1,1,1,1,0,1,1,1,0],PolyVal [1,0,0,0,0,1,1,0,1,1,0,0,0,1,0,1,1,1,1,0,1,1,0,1,1,1,1,1,0,1,0,0,1,1,0,1,1,0,1,0,1,1,1,1,1,0,0,1,0,1,0,0,1,1,0,0,0,1,1,0,1,0,1,0]],IndexVal 0], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_p64(UINT64_C(0x7cb0871b1dbda90b));
      arg3 = vcombine_p64(vcreate_p64(UINT64_C(0x77cc6aa0a39aa20c)),
                          vcreate_p64(UINT64_C(0x56329f5b2fb7a361)));
      clear_neon_saturated();
      //  Expect: "result" = 77cc6aa0a39aa20c
      result = vcopy_laneq_p64(arg1, 0, arg3, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_p64(result), 0);
      exp = UINT64_C(0x77cc6aa0a39aa20c);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1849() {

{
   {
      poly64x1_t arg1;
      poly64x1_t arg3;
      poly64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"ins_lane\", fnname = \"vcopy_lane_p64\", rettype = \"poly64x1_t\", argtypes = \"[poly64x1_t,__constrange(0,0) int,poly64x1_t,__constrange(0,0) int]\", vals = [VectorVal [PolyVal [0,0,0,1,0,1,1,1,1,1,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,1,0,1,0,1,1,0,1,1,1,1,1,1,1,0,1,1,0,0,0,1,0,0,1,1,1,1,0,0,1,1,1,0,1,1,1,0]],IndexVal 0,VectorVal [PolyVal [0,1,1,1,0,0,1,0,1,0,1,0,0,0,0,1,1,0,1,0,0,1,0,0,1,1,0,0,0,0,0,1,0,0,1,1,1,1,1,1,1,0,1,0,1,1,0,0,1,1,1,0,1,1,0,0,0,1,1,0,0,0,1,0]],IndexVal 0], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_p64(UINT64_C(0x773c8dfdac840be8));
      arg3 = vcreate_p64(UINT64_C(0x463735fc8325854e));
      clear_neon_saturated();
      //  Expect: "result" = 463735fc8325854e
      result = vcopy_lane_p64(arg1, 0, arg3, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_p64(result), 0);
      exp = UINT64_C(0x463735fc8325854e);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1850() {

{
   {
      uint64_t arg1;
      int8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"create\", fnname = \"vcreate_s8\", rettype = \"int8x8_t\", argtypes = \"[uint64_t]\", vals = [IntegerVal 18446462598732873727], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = UINT64_C(0xffff000000007fff);
      clear_neon_saturated();
      //  Expect: "result" = ffff000000007fff
      result = vcreate_s8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s8(result), 0);
      exp = UINT64_C(0xffff000000007fff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1851() {

{
   {
      uint64_t arg1;
      int16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"create\", fnname = \"vcreate_s16\", rettype = \"int16x4_t\", argtypes = \"[uint64_t]\", vals = [IntegerVal 18446462600880324607], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = UINT64_C(0xffff00007fffffff);
      clear_neon_saturated();
      //  Expect: "result" = ffff00007fffffff
      result = vcreate_s16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s16(result), 0);
      exp = UINT64_C(0xffff00007fffffff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1852() {

{
   {
      uint64_t arg1;
      int32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"create\", fnname = \"vcreate_s32\", rettype = \"int32x2_t\", argtypes = \"[uint64_t]\", vals = [IntegerVal 18446467125628436479], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = UINT64_C(0xffff041e0000ffff);
      clear_neon_saturated();
      //  Expect: "result" = ffff041e0000ffff
      result = vcreate_s32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s32(result), 0);
      exp = UINT64_C(0xffff041e0000ffff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1853() {

{
   {
      uint64_t arg1;
      float32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"create\", fnname = \"vcreate_f32\", rettype = \"float32x2_t\", argtypes = \"[uint64_t]\", vals = [IntegerVal 4557319052146006137], start_saturated = True}";
      int reported = 0;
      arg1 = UINT64_C(0x3f3ed9883f485879);
      set_neon_saturated();
      //  Expect: "result" = 3f3ed9883f485879
      result = vcreate_f32(arg1);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result, 0);
         exp = ((float32_t) 0.7825999855995178);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result, 1);
         exp = ((float32_t) 0.745506763458252);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
   }
}
}
void dotests_1854() {

{
   {
      uint64_t arg1;
      uint8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"create\", fnname = \"vcreate_u8\", rettype = \"uint8x8_t\", argtypes = \"[uint64_t]\", vals = [IntegerVal 18446744071562090502], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = UINT64_C(0xffffffff80005806);
      clear_neon_saturated();
      //  Expect: "result" = ffffffff80005806
      result = vcreate_u8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u8(result), 0);
      exp = UINT64_C(0xffffffff80005806);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1855() {

{
   {
      uint64_t arg1;
      uint16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"create\", fnname = \"vcreate_u16\", rettype = \"uint16x4_t\", argtypes = \"[uint64_t]\", vals = [IntegerVal 2147418112], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = UINT64_C(0x000000007fff0000);
      clear_neon_saturated();
      //  Expect: "result" = 000000007fff0000
      result = vcreate_u16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u16(result), 0);
      exp = UINT64_C(0x000000007fff0000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1856() {

{
   {
      uint64_t arg1;
      uint32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"create\", fnname = \"vcreate_u32\", rettype = \"uint32x2_t\", argtypes = \"[uint64_t]\", vals = [IntegerVal 18446603334073679871], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = UINT64_C(0xffff7fff7fff7fff);
      clear_neon_saturated();
      //  Expect: "result" = ffff7fff7fff7fff
      result = vcreate_u32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u32(result), 0);
      exp = UINT64_C(0xffff7fff7fff7fff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1857() {

{
   {
      uint64_t arg1;
      uint64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"create\", fnname = \"vcreate_u64\", rettype = \"uint64x1_t\", argtypes = \"[uint64_t]\", vals = [IntegerVal 15058911254020108323], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = UINT64_C(0xd0fc000000003023);
      clear_neon_saturated();
      //  Expect: "result" = d0fc000000003023
      result = vcreate_u64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(result, 0);
      exp = UINT64_C(0xd0fc000000003023);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1858() {

{
   {
      uint64_t arg1;
      poly8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"create\", fnname = \"vcreate_p8\", rettype = \"poly8x8_t\", argtypes = \"[uint64_t]\", vals = [IntegerVal 9223372032559813914], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = UINT64_C(0x7fffffff0000151a);
      clear_neon_saturated();
      //  Expect: "result" = 7fffffff0000151a
      result = vcreate_p8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_p8(result), 0);
      exp = UINT64_C(0x7fffffff0000151a);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1859() {

{
   {
      uint64_t arg1;
      poly16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"create\", fnname = \"vcreate_p16\", rettype = \"poly16x4_t\", argtypes = \"[uint64_t]\", vals = [IntegerVal 2912280850831736831], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = UINT64_C(0x286a8000ffff7fff);
      clear_neon_saturated();
      //  Expect: "result" = 286a8000ffff7fff
      result = vcreate_p16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_p16(result), 0);
      exp = UINT64_C(0x286a8000ffff7fff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1860() {

{
   {
      uint64_t arg1;
      int64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"create\", fnname = \"vcreate_s64\", rettype = \"int64x1_t\", argtypes = \"[uint64_t]\", vals = [IntegerVal 9223231299366453248], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = UINT64_C(0x7fff800000008000);
      clear_neon_saturated();
      //  Expect: "result" = 7fff800000008000
      result = vcreate_s64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s64(result), 0);
      exp = UINT64_C(0x7fff800000008000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1861() {
#if __ARM_NEON_FP16_INTRINSICS

{
   {
      uint64_t arg1;
      float16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"create\", fnname = \"vcreate_f16\", rettype = \"float16x4_t\", argtypes = \"[uint64_t]\", vals = [IntegerVal 4448053469220953326], start_saturated = False}";
      int reported = 0;
      arg1 = UINT64_C(0x3dbaa9103edbdcee);
      clear_neon_saturated();
      //  Expect: "result" = 3dbaa9103edbdcee
      result = vcreate_f16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         __fp16 got;
         __fp16 exp;
         got = vget_lane_f16(result, 0);
         exp = -315.5;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vget_lane_f16(result, 1);
         exp = 1.7138671875;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vget_lane_f16(result, 2);
         exp = -3.955078125e-2;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 2 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vget_lane_f16(result, 3);
         exp = 1.431640625;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 3 ", exp, got);
            }
      }
   }
}
#endif
}
void dotests_1862() {

{
   {
      uint64_t arg1;
      float64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"create\", fnname = \"vcreate_f64\", rettype = \"float64x1_t\", argtypes = \"[uint64_t]\", vals = [IntegerVal 4605959608628585881], start_saturated = False}";
      int reported = 0;
      float64_t got;
      float64_t exp;
      arg1 = UINT64_C(0x3feba7dc521aa599);
      clear_neon_saturated();
      //  Expect: "result" = 3feba7dc521aa599
      result = vcreate_f64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_f64(result, 0);
      exp = 0.8642407992930884;
      if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
         }
   }
}
}
void dotests_1863() {

{
   {
      uint64_t arg1;
      poly64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"create\", fnname = \"vcreate_p64\", rettype = \"poly64x1_t\", argtypes = \"[uint64_t]\", vals = [IntegerVal 134502238650367], start_saturated = True}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = UINT64_C(0x00007a543e27ffff);
      set_neon_saturated();
      //  Expect: "result" = 00007a543e27ffff
      result = vcreate_p64(arg1);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_p64(result), 0);
      exp = UINT64_C(0x00007a543e27ffff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1864() {

{
   {
      uint8_t arg1;
      uint8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"set_all_lanes\", fnname = \"vdup_n_u8\", rettype = \"uint8x8_t\", argtypes = \"[uint8_t]\", vals = [IntegerVal 0], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = 0;
      clear_neon_saturated();
      //  Expect: "result" = 0000000000000000
      result = vdup_n_u8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u8(result), 0);
      exp = 0;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1865() {

{
   {
      uint16_t arg1;
      uint16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"set_all_lanes\", fnname = \"vdup_n_u16\", rettype = \"uint16x4_t\", argtypes = \"[uint16_t]\", vals = [IntegerVal 32768], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = 32768U;
      clear_neon_saturated();
      //  Expect: "result" = 8000800080008000
      result = vdup_n_u16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u16(result), 0);
      exp = UINT64_C(0x8000800080008000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1866() {

{
   {
      uint32_t arg1;
      uint32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"set_all_lanes\", fnname = \"vdup_n_u32\", rettype = \"uint32x2_t\", argtypes = \"[uint32_t]\", vals = [IntegerVal 32768], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = 32768U;
      clear_neon_saturated();
      //  Expect: "result" = 0000800000008000
      result = vdup_n_u32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u32(result), 0);
      exp = UINT64_C(0x0000800000008000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1867() {

{
   {
      int8_t arg1;
      int8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"set_all_lanes\", fnname = \"vdup_n_s8\", rettype = \"int8x8_t\", argtypes = \"[int8_t]\", vals = [IntegerVal (-3)], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = -3;
      clear_neon_saturated();
      //  Expect: "result" = fdfdfdfdfdfdfdfd
      result = vdup_n_s8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s8(result), 0);
      exp = UINT64_C(0xfdfdfdfdfdfdfdfd);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1868() {

{
   {
      int16_t arg1;
      int16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"set_all_lanes\", fnname = \"vdup_n_s16\", rettype = \"int16x4_t\", argtypes = \"[int16_t]\", vals = [IntegerVal (-11756)], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = -11756;
      clear_neon_saturated();
      //  Expect: "result" = d214d214d214d214
      result = vdup_n_s16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s16(result), 0);
      exp = UINT64_C(0xd214d214d214d214);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1869() {

{
   {
      int32_t arg1;
      int32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"set_all_lanes\", fnname = \"vdup_n_s32\", rettype = \"int32x2_t\", argtypes = \"[int32_t]\", vals = [IntegerVal 2147483647], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = 2147483647;
      clear_neon_saturated();
      //  Expect: "result" = 7fffffff7fffffff
      result = vdup_n_s32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s32(result), 0);
      exp = UINT64_C(0x7fffffff7fffffff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1870() {

{
   {
      poly8_t arg1;
      poly8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"set_all_lanes\", fnname = \"vdup_n_p8\", rettype = \"poly8x8_t\", argtypes = \"[poly8_t]\", vals = [PolyVal [0,1,0,0,1,0,1,1]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = 210;
      clear_neon_saturated();
      //  Expect: "result" = d2d2d2d2d2d2d2d2
      result = vdup_n_p8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_p8(result), 0);
      exp = UINT64_C(0xd2d2d2d2d2d2d2d2);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1871() {

{
   {
      poly16_t arg1;
      poly16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"set_all_lanes\", fnname = \"vdup_n_p16\", rettype = \"poly16x4_t\", argtypes = \"[poly16_t]\", vals = [PolyVal [1,1,1,0,1,1,0,0,0,0,1,1,0,0,0,1]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = 35895;
      clear_neon_saturated();
      //  Expect: "result" = 8c378c378c378c37
      result = vdup_n_p16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_p16(result), 0);
      exp = UINT64_C(0x8c378c378c378c37);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1872() {

{
   {
      float32_t arg1;
      float32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"set_all_lanes\", fnname = \"vdup_n_f32\", rettype = \"float32x2_t\", argtypes = \"[float32_t]\", vals = [FloatVal 0.9053750038146973], start_saturated = False}";
      int reported = 0;
      arg1 = ((float32_t) 0.9053750038146973);
      clear_neon_saturated();
      //  Expect: "result" = 3f67c6a83f67c6a8
      result = vdup_n_f32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result, 0);
         exp = ((float32_t) 0.9053750038146973);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result, 1);
         exp = ((float32_t) 0.9053750038146973);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
   }
}
}
void dotests_1873() {

{
   {
      uint8_t arg1;
      uint8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"set_all_lanes\", fnname = \"vdupq_n_u8\", rettype = \"uint8x16_t\", argtypes = \"[uint8_t]\", vals = [IntegerVal 128], start_saturated = False}";
      int reported = 0;
      arg1 = 128U;
      clear_neon_saturated();
      //  Expect: "result" = 80808080808080808080808080808080
      result = vdupq_n_u8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 0);
         exp = UINT64_C(0x8080808080808080);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 1);
         exp = UINT64_C(0x8080808080808080);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1874() {

{
   {
      uint16_t arg1;
      uint16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"set_all_lanes\", fnname = \"vdupq_n_u16\", rettype = \"uint16x8_t\", argtypes = \"[uint16_t]\", vals = [IntegerVal 65535], start_saturated = False}";
      int reported = 0;
      arg1 = 65535U;
      clear_neon_saturated();
      //  Expect: "result" = ffffffffffffffffffffffffffffffff
      result = vdupq_n_u16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 0);
         exp = UINT64_C(0xffffffffffffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 1);
         exp = UINT64_C(0xffffffffffffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1875() {

{
   {
      uint32_t arg1;
      uint32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"set_all_lanes\", fnname = \"vdupq_n_u32\", rettype = \"uint32x4_t\", argtypes = \"[uint32_t]\", vals = [IntegerVal 4294901760], start_saturated = False}";
      int reported = 0;
      arg1 = 4294901760U;
      clear_neon_saturated();
      //  Expect: "result" = ffff0000ffff0000ffff0000ffff0000
      result = vdupq_n_u32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 0);
         exp = UINT64_C(0xffff0000ffff0000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 1);
         exp = UINT64_C(0xffff0000ffff0000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1876() {

{
   {
      int8_t arg1;
      int8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"set_all_lanes\", fnname = \"vdupq_n_s8\", rettype = \"int8x16_t\", argtypes = \"[int8_t]\", vals = [IntegerVal 127], start_saturated = True}";
      int reported = 0;
      arg1 = 127;
      set_neon_saturated();
      //  Expect: "result" = 7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f
      result = vdupq_n_s8(arg1);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result), 0);
         exp = UINT64_C(0x7f7f7f7f7f7f7f7f);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result), 1);
         exp = UINT64_C(0x7f7f7f7f7f7f7f7f);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1877() {

{
   {
      int16_t arg1;
      int16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"set_all_lanes\", fnname = \"vdupq_n_s16\", rettype = \"int16x8_t\", argtypes = \"[int16_t]\", vals = [IntegerVal (-1)], start_saturated = True}";
      int reported = 0;
      arg1 = -1;
      set_neon_saturated();
      //  Expect: "result" = ffffffffffffffffffffffffffffffff
      result = vdupq_n_s16(arg1);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 0);
         exp = UINT64_C(0xffffffffffffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 1);
         exp = UINT64_C(0xffffffffffffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1878() {

{
   {
      int32_t arg1;
      int32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"set_all_lanes\", fnname = \"vdupq_n_s32\", rettype = \"int32x4_t\", argtypes = \"[int32_t]\", vals = [IntegerVal (-1225654272)], start_saturated = False}";
      int reported = 0;
      arg1 = -1225654272;
      clear_neon_saturated();
      //  Expect: "result" = b6f20000b6f20000b6f20000b6f20000
      result = vdupq_n_s32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 0);
         exp = UINT64_C(0xb6f20000b6f20000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 1);
         exp = UINT64_C(0xb6f20000b6f20000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1879() {

{
   {
      poly8_t arg1;
      poly8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"set_all_lanes\", fnname = \"vdupq_n_p8\", rettype = \"poly8x16_t\", argtypes = \"[poly8_t]\", vals = [PolyVal [0,1,1,1,1,1,0,1]], start_saturated = False}";
      int reported = 0;
      arg1 = 190;
      clear_neon_saturated();
      //  Expect: "result" = bebebebebebebebebebebebebebebebe
      result = vdupq_n_p8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p8(result), 0);
         exp = UINT64_C(0xbebebebebebebebe);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p8(result), 1);
         exp = UINT64_C(0xbebebebebebebebe);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1880() {

{
   {
      poly16_t arg1;
      poly16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"set_all_lanes\", fnname = \"vdupq_n_p16\", rettype = \"poly16x8_t\", argtypes = \"[poly16_t]\", vals = [PolyVal [1,1,1,1,1,0,1,1,1,1,0,0,1,1,0,1]], start_saturated = False}";
      int reported = 0;
      arg1 = 46047;
      clear_neon_saturated();
      //  Expect: "result" = b3dfb3dfb3dfb3dfb3dfb3dfb3dfb3df
      result = vdupq_n_p16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p16(result), 0);
         exp = UINT64_C(0xb3dfb3dfb3dfb3df);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p16(result), 1);
         exp = UINT64_C(0xb3dfb3dfb3dfb3df);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1881() {

{
   {
      float32_t arg1;
      float32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"set_all_lanes\", fnname = \"vdupq_n_f32\", rettype = \"float32x4_t\", argtypes = \"[float32_t]\", vals = [FloatVal 0.6984418630599976], start_saturated = False}";
      int reported = 0;
      arg1 = ((float32_t) 0.6984418630599976);
      clear_neon_saturated();
      //  Expect: "result" = 3f32cd163f32cd163f32cd163f32cd16
      result = vdupq_n_f32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 0);
         exp = ((float32_t) 0.6984418630599976);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 1);
         exp = ((float32_t) 0.6984418630599976);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 2);
         exp = ((float32_t) 0.6984418630599976);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 2 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 3);
         exp = ((float32_t) 0.6984418630599976);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 3 ", exp, got);
            }
      }
   }
}
}
void dotests_1882() {

{
   {
      int64_t arg1;
      int64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"set_all_lanes\", fnname = \"vdup_n_s64\", rettype = \"int64x1_t\", argtypes = \"[int64_t]\", vals = [IntegerVal (-2147508401)], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = INT64_C(-2147508401);
      clear_neon_saturated();
      //  Expect: "result" = ffffffff7fff9f4f
      result = vdup_n_s64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s64(result), 0);
      exp = UINT64_C(0xffffffff7fff9f4f);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1883() {

{
   {
      uint64_t arg1;
      uint64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"set_all_lanes\", fnname = \"vdup_n_u64\", rettype = \"uint64x1_t\", argtypes = \"[uint64_t]\", vals = [IntegerVal 9223353020887007232], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = UINT64_C(0x7fffeeb47fff0000);
      clear_neon_saturated();
      //  Expect: "result" = 7fffeeb47fff0000
      result = vdup_n_u64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(result, 0);
      exp = UINT64_C(0x7fffeeb47fff0000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1884() {

{
   {
      int64_t arg1;
      int64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"set_all_lanes\", fnname = \"vdupq_n_s64\", rettype = \"int64x2_t\", argtypes = \"[int64_t]\", vals = [IntegerVal 281470681808895], start_saturated = False}";
      int reported = 0;
      arg1 = INT64_C(281470681808895);
      clear_neon_saturated();
      //  Expect: "result" = 0000ffff0000ffff0000ffff0000ffff
      result = vdupq_n_s64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 0);
         exp = UINT64_C(0x0000ffff0000ffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 1);
         exp = UINT64_C(0x0000ffff0000ffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1885() {

{
   {
      uint64_t arg1;
      uint64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"set_all_lanes\", fnname = \"vdupq_n_u64\", rettype = \"uint64x2_t\", argtypes = \"[uint64_t]\", vals = [IntegerVal 18446462600880324608], start_saturated = True}";
      int reported = 0;
      arg1 = UINT64_C(0xffff000080000000);
      set_neon_saturated();
      //  Expect: "result" = ffff000080000000ffff000080000000
      result = vdupq_n_u64(arg1);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 0);
         exp = UINT64_C(0xffff000080000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 1);
         exp = UINT64_C(0xffff000080000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1886() {

{
   {
      float64_t arg1;
      float64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"set_all_lanes\", fnname = \"vdup_n_f64\", rettype = \"float64x1_t\", argtypes = \"[float64_t]\", vals = [FloatVal 1.1673859046426038e-2], start_saturated = False}";
      int reported = 0;
      float64_t got;
      float64_t exp;
      arg1 = 1.1673859046426038e-2;
      clear_neon_saturated();
      //  Expect: "result" = 3f87e876d6948200
      result = vdup_n_f64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_f64(result, 0);
      exp = 1.1673859046426038e-2;
      if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
         }
   }
}
}
void dotests_1887() {

{
   {
      float64_t arg1;
      float64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"set_all_lanes\", fnname = \"vdupq_n_f64\", rettype = \"float64x2_t\", argtypes = \"[float64_t]\", vals = [FloatVal 0.35758402829409475], start_saturated = False}";
      int reported = 0;
      arg1 = 0.35758402829409475;
      clear_neon_saturated();
      //  Expect: "result" = 3fd6e2a81ec615b83fd6e2a81ec615b8
      result = vdupq_n_f64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float64_t got;
         float64_t exp;
         got = vgetq_lane_f64(result, 0);
         exp = 0.35758402829409475;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float64_t got;
         float64_t exp;
         got = vgetq_lane_f64(result, 1);
         exp = 0.35758402829409475;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
   }
}
}
void dotests_1888() {

{
   {
      poly64_t arg1;
      poly64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"set_all_lanes\", fnname = \"vdup_n_p64\", rettype = \"poly64x1_t\", argtypes = \"[poly64_t]\", vals = [PolyVal [0,1,0,0,0,0,0,1,1,0,1,0,0,1,0,0,0,0,0,0,1,1,1,1,1,0,1,0,1,0,1,0,1,0,0,1,0,0,1,1,0,1,0,0,0,0,0,0,0,0,1,0,1,1,0,1,1,1,1,0,0,1,0,0]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = 2860914727040591234;
      clear_neon_saturated();
      //  Expect: "result" = 27b402c955f02582
      result = vdup_n_p64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_p64(result), 0);
      exp = UINT64_C(0x27b402c955f02582);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1889() {

{
   {
      poly64_t arg1;
      poly64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"set_all_lanes\", fnname = \"vdupq_n_p64\", rettype = \"poly64x2_t\", argtypes = \"[poly64_t]\", vals = [PolyVal [1,1,1,0,1,0,0,0,1,1,0,1,1,1,1,0,1,0,0,0,1,0,0,0,1,1,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,1,1,1,0,1,1,1,0,1,0,1,0,0,0,0,0,0,1,1,1,0]], start_saturated = False}";
      int reported = 0;
      arg1 = 8082760682804706071;
      clear_neon_saturated();
      //  Expect: "result" = 702bbc0447117b17702bbc0447117b17
      result = vdupq_n_p64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p64(result), 0);
         exp = UINT64_C(0x702bbc0447117b17);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p64(result), 1);
         exp = UINT64_C(0x702bbc0447117b17);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1890() {

{
   {
      uint8_t arg1;
      uint8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"set_all_lanes\", fnname = \"vmov_n_u8\", rettype = \"uint8x8_t\", argtypes = \"[uint8_t]\", vals = [IntegerVal 0], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = 0;
      clear_neon_saturated();
      //  Expect: "result" = 0000000000000000
      result = vmov_n_u8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u8(result), 0);
      exp = 0;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1891() {

{
   {
      uint16_t arg1;
      uint16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"set_all_lanes\", fnname = \"vmov_n_u16\", rettype = \"uint16x4_t\", argtypes = \"[uint16_t]\", vals = [IntegerVal 14590], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = 14590U;
      clear_neon_saturated();
      //  Expect: "result" = 38fe38fe38fe38fe
      result = vmov_n_u16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u16(result), 0);
      exp = UINT64_C(0x38fe38fe38fe38fe);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1892() {

{
   {
      uint32_t arg1;
      uint32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"set_all_lanes\", fnname = \"vmov_n_u32\", rettype = \"uint32x2_t\", argtypes = \"[uint32_t]\", vals = [IntegerVal 0], start_saturated = True}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = 0;
      set_neon_saturated();
      //  Expect: "result" = 0000000000000000
      result = vmov_n_u32(arg1);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u32(result), 0);
      exp = 0;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1893() {

{
   {
      int8_t arg1;
      int8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"set_all_lanes\", fnname = \"vmov_n_s8\", rettype = \"int8x8_t\", argtypes = \"[int8_t]\", vals = [IntegerVal 0], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = 0;
      clear_neon_saturated();
      //  Expect: "result" = 0000000000000000
      result = vmov_n_s8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s8(result), 0);
      exp = 0;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1894() {

{
   {
      int16_t arg1;
      int16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"set_all_lanes\", fnname = \"vmov_n_s16\", rettype = \"int16x4_t\", argtypes = \"[int16_t]\", vals = [IntegerVal (-1)], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = -1;
      clear_neon_saturated();
      //  Expect: "result" = ffffffffffffffff
      result = vmov_n_s16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s16(result), 0);
      exp = UINT64_C(0xffffffffffffffff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1895() {

{
   {
      int32_t arg1;
      int32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"set_all_lanes\", fnname = \"vmov_n_s32\", rettype = \"int32x2_t\", argtypes = \"[int32_t]\", vals = [IntegerVal 32768], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = 32768;
      clear_neon_saturated();
      //  Expect: "result" = 0000800000008000
      result = vmov_n_s32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s32(result), 0);
      exp = UINT64_C(0x0000800000008000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1896() {

{
   {
      poly8_t arg1;
      poly8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"set_all_lanes\", fnname = \"vmov_n_p8\", rettype = \"poly8x8_t\", argtypes = \"[poly8_t]\", vals = [PolyVal [1,1,1,1,1,0,0,0]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = 31;
      clear_neon_saturated();
      //  Expect: "result" = 1f1f1f1f1f1f1f1f
      result = vmov_n_p8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_p8(result), 0);
      exp = UINT64_C(0x1f1f1f1f1f1f1f1f);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1897() {

{
   {
      poly16_t arg1;
      poly16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"set_all_lanes\", fnname = \"vmov_n_p16\", rettype = \"poly16x4_t\", argtypes = \"[poly16_t]\", vals = [PolyVal [0,1,1,1,0,0,0,0,0,0,1,1,0,1,0,1]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = 44046;
      clear_neon_saturated();
      //  Expect: "result" = ac0eac0eac0eac0e
      result = vmov_n_p16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_p16(result), 0);
      exp = UINT64_C(0xac0eac0eac0eac0e);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1898() {

{
   {
      float32_t arg1;
      float32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"set_all_lanes\", fnname = \"vmov_n_f32\", rettype = \"float32x2_t\", argtypes = \"[float32_t]\", vals = [FloatVal 0.46967369318008423], start_saturated = False}";
      int reported = 0;
      arg1 = ((float32_t) 0.46967369318008423);
      clear_neon_saturated();
      //  Expect: "result" = 3ef079123ef07912
      result = vmov_n_f32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result, 0);
         exp = ((float32_t) 0.46967369318008423);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result, 1);
         exp = ((float32_t) 0.46967369318008423);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
   }
}
}
void dotests_1899() {

{
   {
      uint8_t arg1;
      uint8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"set_all_lanes\", fnname = \"vmovq_n_u8\", rettype = \"uint8x16_t\", argtypes = \"[uint8_t]\", vals = [IntegerVal 0], start_saturated = True}";
      int reported = 0;
      arg1 = 0;
      set_neon_saturated();
      //  Expect: "result" = 00000000000000000000000000000000
      result = vmovq_n_u8(arg1);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 0);
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 1);
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1900() {

{
   {
      uint16_t arg1;
      uint16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"set_all_lanes\", fnname = \"vmovq_n_u16\", rettype = \"uint16x8_t\", argtypes = \"[uint16_t]\", vals = [IntegerVal 0], start_saturated = False}";
      int reported = 0;
      arg1 = 0;
      clear_neon_saturated();
      //  Expect: "result" = 00000000000000000000000000000000
      result = vmovq_n_u16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 0);
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 1);
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1901() {

{
   {
      uint32_t arg1;
      uint32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"set_all_lanes\", fnname = \"vmovq_n_u32\", rettype = \"uint32x4_t\", argtypes = \"[uint32_t]\", vals = [IntegerVal 2147483648], start_saturated = False}";
      int reported = 0;
      arg1 = 2147483648U;
      clear_neon_saturated();
      //  Expect: "result" = 80000000800000008000000080000000
      result = vmovq_n_u32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 0);
         exp = UINT64_C(0x8000000080000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 1);
         exp = UINT64_C(0x8000000080000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1902() {

{
   {
      int8_t arg1;
      int8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"set_all_lanes\", fnname = \"vmovq_n_s8\", rettype = \"int8x16_t\", argtypes = \"[int8_t]\", vals = [IntegerVal 0], start_saturated = False}";
      int reported = 0;
      arg1 = 0;
      clear_neon_saturated();
      //  Expect: "result" = 00000000000000000000000000000000
      result = vmovq_n_s8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result), 0);
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result), 1);
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1903() {

{
   {
      int16_t arg1;
      int16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"set_all_lanes\", fnname = \"vmovq_n_s16\", rettype = \"int16x8_t\", argtypes = \"[int16_t]\", vals = [IntegerVal 0], start_saturated = False}";
      int reported = 0;
      arg1 = 0;
      clear_neon_saturated();
      //  Expect: "result" = 00000000000000000000000000000000
      result = vmovq_n_s16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 0);
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 1);
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1904() {

{
   {
      int32_t arg1;
      int32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"set_all_lanes\", fnname = \"vmovq_n_s32\", rettype = \"int32x4_t\", argtypes = \"[int32_t]\", vals = [IntegerVal (-2147476312)], start_saturated = False}";
      int reported = 0;
      arg1 = -2147476312;
      clear_neon_saturated();
      //  Expect: "result" = 80001ca880001ca880001ca880001ca8
      result = vmovq_n_s32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 0);
         exp = UINT64_C(0x80001ca880001ca8);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 1);
         exp = UINT64_C(0x80001ca880001ca8);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1905() {

{
   {
      poly8_t arg1;
      poly8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"set_all_lanes\", fnname = \"vmovq_n_p8\", rettype = \"poly8x16_t\", argtypes = \"[poly8_t]\", vals = [PolyVal [0,1,0,0,0,0,0,1]], start_saturated = False}";
      int reported = 0;
      arg1 = 130;
      clear_neon_saturated();
      //  Expect: "result" = 82828282828282828282828282828282
      result = vmovq_n_p8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p8(result), 0);
         exp = UINT64_C(0x8282828282828282);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p8(result), 1);
         exp = UINT64_C(0x8282828282828282);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1906() {

{
   {
      poly16_t arg1;
      poly16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"set_all_lanes\", fnname = \"vmovq_n_p16\", rettype = \"poly16x8_t\", argtypes = \"[poly16_t]\", vals = [PolyVal [0,1,1,1,1,0,0,1,0,1,1,0,1,1,0,1]], start_saturated = False}";
      int reported = 0;
      arg1 = 46750;
      clear_neon_saturated();
      //  Expect: "result" = b69eb69eb69eb69eb69eb69eb69eb69e
      result = vmovq_n_p16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p16(result), 0);
         exp = UINT64_C(0xb69eb69eb69eb69e);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p16(result), 1);
         exp = UINT64_C(0xb69eb69eb69eb69e);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1907() {

{
   {
      float32_t arg1;
      float32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"set_all_lanes\", fnname = \"vmovq_n_f32\", rettype = \"float32x4_t\", argtypes = \"[float32_t]\", vals = [FloatVal 0.7846850156784058], start_saturated = False}";
      int reported = 0;
      arg1 = ((float32_t) 0.7846850156784058);
      clear_neon_saturated();
      //  Expect: "result" = 3f48e11e3f48e11e3f48e11e3f48e11e
      result = vmovq_n_f32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 0);
         exp = ((float32_t) 0.7846850156784058);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 1);
         exp = ((float32_t) 0.7846850156784058);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 2);
         exp = ((float32_t) 0.7846850156784058);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 2 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 3);
         exp = ((float32_t) 0.7846850156784058);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 3 ", exp, got);
            }
      }
   }
}
}
void dotests_1908() {

{
   {
      int64_t arg1;
      int64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"set_all_lanes\", fnname = \"vmov_n_s64\", rettype = \"int64x1_t\", argtypes = \"[int64_t]\", vals = [IntegerVal 9223372032559841280], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = INT64_C(9223372032559841280);
      clear_neon_saturated();
      //  Expect: "result" = 7fffffff00008000
      result = vmov_n_s64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s64(result), 0);
      exp = UINT64_C(0x7fffffff00008000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1909() {

{
   {
      uint64_t arg1;
      uint64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"set_all_lanes\", fnname = \"vmov_n_u64\", rettype = \"uint64x1_t\", argtypes = \"[uint64_t]\", vals = [IntegerVal 9223231295071518719], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = UINT64_C(0x7fff7fff0000ffff);
      clear_neon_saturated();
      //  Expect: "result" = 7fff7fff0000ffff
      result = vmov_n_u64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(result, 0);
      exp = UINT64_C(0x7fff7fff0000ffff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1910() {

{
   {
      int64_t arg1;
      int64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"set_all_lanes\", fnname = \"vmovq_n_s64\", rettype = \"int64x2_t\", argtypes = \"[int64_t]\", vals = [IntegerVal 140737488393464], start_saturated = False}";
      int reported = 0;
      arg1 = INT64_C(140737488393464);
      clear_neon_saturated();
      //  Expect: "result" = 00008000000094f800008000000094f8
      result = vmovq_n_s64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 0);
         exp = UINT64_C(0x00008000000094f8);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 1);
         exp = UINT64_C(0x00008000000094f8);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1911() {

{
   {
      uint64_t arg1;
      uint64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"set_all_lanes\", fnname = \"vmovq_n_u64\", rettype = \"uint64x2_t\", argtypes = \"[uint64_t]\", vals = [IntegerVal 9223480645840237931], start_saturated = False}";
      int reported = 0;
      arg1 = UINT64_C(0x800062c77fff756b);
      clear_neon_saturated();
      //  Expect: "result" = 800062c77fff756b800062c77fff756b
      result = vmovq_n_u64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 0);
         exp = UINT64_C(0x800062c77fff756b);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 1);
         exp = UINT64_C(0x800062c77fff756b);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1912() {

{
   {
      float64_t arg1;
      float64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"set_all_lanes\", fnname = \"vmov_n_f64\", rettype = \"float64x1_t\", argtypes = \"[float64_t]\", vals = [FloatVal 0.5875452955064473], start_saturated = False}";
      int reported = 0;
      float64_t got;
      float64_t exp;
      arg1 = 0.5875452955064473;
      clear_neon_saturated();
      //  Expect: "result" = 3fe2cd2bcaa3cd98
      result = vmov_n_f64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_f64(result, 0);
      exp = 0.5875452955064473;
      if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
         }
   }
}
}
void dotests_1913() {

{
   {
      float64_t arg1;
      float64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"set_all_lanes\", fnname = \"vmovq_n_f64\", rettype = \"float64x2_t\", argtypes = \"[float64_t]\", vals = [FloatVal 0.22716242909881557], start_saturated = False}";
      int reported = 0;
      arg1 = 0.22716242909881557;
      clear_neon_saturated();
      //  Expect: "result" = 3fcd13a891edfe943fcd13a891edfe94
      result = vmovq_n_f64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float64_t got;
         float64_t exp;
         got = vgetq_lane_f64(result, 0);
         exp = 0.22716242909881557;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float64_t got;
         float64_t exp;
         got = vgetq_lane_f64(result, 1);
         exp = 0.22716242909881557;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
   }
}
}
void dotests_1914() {

{
   {
      poly64_t arg1;
      poly64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"set_all_lanes\", fnname = \"vmovq_n_p64\", rettype = \"poly64x2_t\", argtypes = \"[poly64_t]\", vals = [PolyVal [0,0,1,0,0,1,1,1,0,1,0,1,1,1,1,1,1,0,0,0,0,0,1,1,1,1,1,1,1,0,1,0,1,0,0,1,0,1,1,1,1,0,0,0,0,0,0,0,1,1,1,0,0,0,1,0,1,1,1,0,0,1,0,0]], start_saturated = False}";
      int reported = 0;
      arg1 = 2830232992671202020;
      clear_neon_saturated();
      //  Expect: "result" = 274701e95fc1fae4274701e95fc1fae4
      result = vmovq_n_p64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p64(result), 0);
         exp = UINT64_C(0x274701e95fc1fae4);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p64(result), 1);
         exp = UINT64_C(0x274701e95fc1fae4);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1915() {

{
   {
      uint8x8_t arg1;
      uint8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"set_all_lanes_lane\", fnname = \"vdup_lane_u8\", rettype = \"uint8x8_t\", argtypes = \"[uint8x8_t,__constrange(0,7) int]\", vals = [VectorVal [IntegerVal 128,IntegerVal 55,IntegerVal 127,IntegerVal 205,IntegerVal 128,IntegerVal 128,IntegerVal 127,IntegerVal 128],IndexVal 3], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u8(UINT64_C(0x807f8080cd7f3780));
      clear_neon_saturated();
      //  Expect: "result" = cdcdcdcdcdcdcdcd
      result = vdup_lane_u8(arg1, 3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u8(result), 0);
      exp = UINT64_C(0xcdcdcdcdcdcdcdcd);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1916() {

{
   {
      uint16x4_t arg1;
      uint16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"set_all_lanes_lane\", fnname = \"vdup_lane_u16\", rettype = \"uint16x4_t\", argtypes = \"[uint16x4_t,__constrange(0,3) int]\", vals = [VectorVal [IntegerVal 0,IntegerVal 65535,IntegerVal 34419,IntegerVal 32767],IndexVal 0], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u16(UINT64_C(0x7fff8673ffff0000));
      clear_neon_saturated();
      //  Expect: "result" = 0000000000000000
      result = vdup_lane_u16(arg1, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u16(result), 0);
      exp = 0;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1917() {

{
   {
      uint32x2_t arg1;
      uint32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"set_all_lanes_lane\", fnname = \"vdup_lane_u32\", rettype = \"uint32x2_t\", argtypes = \"[uint32x2_t,__constrange(0,1) int]\", vals = [VectorVal [IntegerVal 2147441862,IntegerVal 32768],IndexVal 1], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u32(UINT64_C(0x000080007fff5cc6));
      clear_neon_saturated();
      //  Expect: "result" = 0000800000008000
      result = vdup_lane_u32(arg1, 1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u32(result), 0);
      exp = UINT64_C(0x0000800000008000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1918() {

{
   {
      int8x8_t arg1;
      int8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"set_all_lanes_lane\", fnname = \"vdup_lane_s8\", rettype = \"int8x8_t\", argtypes = \"[int8x8_t,__constrange(0,7) int]\", vals = [VectorVal [IntegerVal (-128),IntegerVal (-1),IntegerVal 127,IntegerVal (-128),IntegerVal (-128),IntegerVal 127,IntegerVal 0,IntegerVal 112],IndexVal 0], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s8(UINT64_C(0x70007f80807fff80));
      clear_neon_saturated();
      //  Expect: "result" = 8080808080808080
      result = vdup_lane_s8(arg1, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s8(result), 0);
      exp = UINT64_C(0x8080808080808080);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1919() {

{
   {
      int16x4_t arg1;
      int16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"set_all_lanes_lane\", fnname = \"vdup_lane_s16\", rettype = \"int16x4_t\", argtypes = \"[int16x4_t,__constrange(0,3) int]\", vals = [VectorVal [IntegerVal 9864,IntegerVal (-1),IntegerVal 0,IntegerVal 32767],IndexVal 2], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s16(UINT64_C(0x7fff0000ffff2688));
      clear_neon_saturated();
      //  Expect: "result" = 0000000000000000
      result = vdup_lane_s16(arg1, 2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s16(result), 0);
      exp = 0;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1920() {

{
   {
      int32x2_t arg1;
      int32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"set_all_lanes_lane\", fnname = \"vdup_lane_s32\", rettype = \"int32x2_t\", argtypes = \"[int32x2_t,__constrange(0,1) int]\", vals = [VectorVal [IntegerVal (-2147434276),IntegerVal (-436731904)],IndexVal 0], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s32(UINT64_C(0xe5f800008000c0dc));
      clear_neon_saturated();
      //  Expect: "result" = 8000c0dc8000c0dc
      result = vdup_lane_s32(arg1, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s32(result), 0);
      exp = UINT64_C(0x8000c0dc8000c0dc);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1921() {

{
   {
      poly8x8_t arg1;
      poly8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"set_all_lanes_lane\", fnname = \"vdup_lane_p8\", rettype = \"poly8x8_t\", argtypes = \"[poly8x8_t,__constrange(0,7) int]\", vals = [VectorVal [PolyVal [1,0,0,1,0,1,1,1],PolyVal [0,1,0,1,0,1,1,0],PolyVal [1,0,0,0,1,1,0,1],PolyVal [0,1,0,0,0,1,0,1],PolyVal [1,0,1,0,0,0,0,0],PolyVal [1,0,0,0,1,1,1,1],PolyVal [0,1,0,0,1,0,1,0],PolyVal [0,0,1,1,1,1,1,0]],IndexVal 2], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_p8(UINT64_C(0x7c52f105a2b16ae9));
      clear_neon_saturated();
      //  Expect: "result" = b1b1b1b1b1b1b1b1
      result = vdup_lane_p8(arg1, 2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_p8(result), 0);
      exp = UINT64_C(0xb1b1b1b1b1b1b1b1);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1922() {

{
   {
      poly16x4_t arg1;
      poly16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"set_all_lanes_lane\", fnname = \"vdup_lane_p16\", rettype = \"poly16x4_t\", argtypes = \"[poly16x4_t,__constrange(0,3) int]\", vals = [VectorVal [PolyVal [1,0,1,0,0,0,0,0,1,0,1,1,1,0,0,1],PolyVal [1,1,0,1,0,1,0,1,0,0,1,0,1,1,1,0],PolyVal [1,0,0,0,1,0,1,0,0,0,1,0,0,1,0,1],PolyVal [0,0,1,0,0,0,0,0,0,0,1,0,1,0,1,1]],IndexVal 1], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_p16(UINT64_C(0xd404a45174ab9d05));
      clear_neon_saturated();
      //  Expect: "result" = 74ab74ab74ab74ab
      result = vdup_lane_p16(arg1, 1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_p16(result), 0);
      exp = UINT64_C(0x74ab74ab74ab74ab);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1923() {

{
   {
      float32x2_t arg1;
      float32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"set_all_lanes_lane\", fnname = \"vdup_lane_f32\", rettype = \"float32x2_t\", argtypes = \"[float32x2_t,__constrange(0,1) int]\", vals = [VectorVal [FloatVal 0.27269405126571655,FloatVal 1.741945743560791e-2],IndexVal 0], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_f32(UINT64_C(0x3c8eb3403e8b9e8e));
      clear_neon_saturated();
      //  Expect: "result" = 3e8b9e8e3e8b9e8e
      result = vdup_lane_f32(arg1, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result, 0);
         exp = ((float32_t) 0.27269405126571655);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result, 1);
         exp = ((float32_t) 0.27269405126571655);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
   }
}
}
void dotests_1924() {

{
   {
      uint8x8_t arg1;
      uint8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"set_all_lanes_lane\", fnname = \"vdupq_lane_u8\", rettype = \"uint8x16_t\", argtypes = \"[uint8x8_t,__constrange(0,7) int]\", vals = [VectorVal [IntegerVal 128,IntegerVal 21,IntegerVal 127,IntegerVal 128,IntegerVal 127,IntegerVal 126,IntegerVal 2,IntegerVal 0],IndexVal 6], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_u8(UINT64_C(0x00027e7f807f1580));
      clear_neon_saturated();
      //  Expect: "result" = 02020202020202020202020202020202
      result = vdupq_lane_u8(arg1, 6);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 0);
         exp = UINT64_C(0x0202020202020202);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 1);
         exp = UINT64_C(0x0202020202020202);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1925() {

{
   {
      uint16x4_t arg1;
      uint16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"set_all_lanes_lane\", fnname = \"vdupq_lane_u16\", rettype = \"uint16x8_t\", argtypes = \"[uint16x4_t,__constrange(0,3) int]\", vals = [VectorVal [IntegerVal 32768,IntegerVal 52424,IntegerVal 0,IntegerVal 32767],IndexVal 2], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_u16(UINT64_C(0x7fff0000ccc88000));
      clear_neon_saturated();
      //  Expect: "result" = 00000000000000000000000000000000
      result = vdupq_lane_u16(arg1, 2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 0);
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 1);
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1926() {

{
   {
      uint32x2_t arg1;
      uint32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"set_all_lanes_lane\", fnname = \"vdupq_lane_u32\", rettype = \"uint32x4_t\", argtypes = \"[uint32x2_t,__constrange(0,1) int]\", vals = [VectorVal [IntegerVal 2147418112,IntegerVal 442433535],IndexVal 1], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_u32(UINT64_C(0x1a5effff7fff0000));
      clear_neon_saturated();
      //  Expect: "result" = 1a5effff1a5effff1a5effff1a5effff
      result = vdupq_lane_u32(arg1, 1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 0);
         exp = UINT64_C(0x1a5effff1a5effff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 1);
         exp = UINT64_C(0x1a5effff1a5effff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1927() {

{
   {
      int8x8_t arg1;
      int8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"set_all_lanes_lane\", fnname = \"vdupq_lane_s8\", rettype = \"int8x16_t\", argtypes = \"[int8x8_t,__constrange(0,7) int]\", vals = [VectorVal [IntegerVal 127,IntegerVal 100,IntegerVal (-128),IntegerVal 57,IntegerVal 0,IntegerVal 127,IntegerVal (-128),IntegerVal 64],IndexVal 5], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_s8(UINT64_C(0x40807f003980647f));
      clear_neon_saturated();
      //  Expect: "result" = 7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f
      result = vdupq_lane_s8(arg1, 5);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result), 0);
         exp = UINT64_C(0x7f7f7f7f7f7f7f7f);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result), 1);
         exp = UINT64_C(0x7f7f7f7f7f7f7f7f);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1928() {

{
   {
      int16x4_t arg1;
      int16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"set_all_lanes_lane\", fnname = \"vdupq_lane_s16\", rettype = \"int16x8_t\", argtypes = \"[int16x4_t,__constrange(0,3) int]\", vals = [VectorVal [IntegerVal (-32768),IntegerVal (-1),IntegerVal (-1),IntegerVal (-32768)],IndexVal 1], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_s16(UINT64_C(0x8000ffffffff8000));
      clear_neon_saturated();
      //  Expect: "result" = ffffffffffffffffffffffffffffffff
      result = vdupq_lane_s16(arg1, 1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 0);
         exp = UINT64_C(0xffffffffffffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 1);
         exp = UINT64_C(0xffffffffffffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1929() {

{
   {
      int32x2_t arg1;
      int32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"set_all_lanes_lane\", fnname = \"vdupq_lane_s32\", rettype = \"int32x4_t\", argtypes = \"[int32x2_t,__constrange(0,1) int]\", vals = [VectorVal [IntegerVal 1679753216,IntegerVal (-2147450881)],IndexVal 1], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_s32(UINT64_C(0x80007fff641f0000));
      clear_neon_saturated();
      //  Expect: "result" = 80007fff80007fff80007fff80007fff
      result = vdupq_lane_s32(arg1, 1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 0);
         exp = UINT64_C(0x80007fff80007fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 1);
         exp = UINT64_C(0x80007fff80007fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1930() {

{
   {
      poly8x8_t arg1;
      poly8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"set_all_lanes_lane\", fnname = \"vdupq_lane_p8\", rettype = \"poly8x16_t\", argtypes = \"[poly8x8_t,__constrange(0,7) int]\", vals = [VectorVal [PolyVal [0,0,0,0,1,0,0,0],PolyVal [0,0,1,1,1,0,0,0],PolyVal [0,1,1,1,0,1,1,0],PolyVal [1,0,1,1,0,0,1,0],PolyVal [1,0,0,0,1,1,1,0],PolyVal [1,1,1,1,0,1,1,1],PolyVal [0,1,0,1,1,0,0,1],PolyVal [0,0,1,1,0,0,0,1]],IndexVal 5], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_p8(UINT64_C(0x8c9aef714d6e1c10));
      clear_neon_saturated();
      //  Expect: "result" = efefefefefefefefefefefefefefefef
      result = vdupq_lane_p8(arg1, 5);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p8(result), 0);
         exp = UINT64_C(0xefefefefefefefef);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p8(result), 1);
         exp = UINT64_C(0xefefefefefefefef);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1931() {

{
   {
      poly16x4_t arg1;
      poly16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"set_all_lanes_lane\", fnname = \"vdupq_lane_p16\", rettype = \"poly16x8_t\", argtypes = \"[poly16x4_t,__constrange(0,3) int]\", vals = [VectorVal [PolyVal [1,0,0,1,0,0,1,0,1,1,1,1,1,0,0,0],PolyVal [1,0,0,1,0,1,1,1,1,0,0,1,0,0,1,0],PolyVal [0,0,1,1,0,1,0,1,1,1,1,0,1,1,1,0],PolyVal [1,1,1,1,0,0,1,0,0,0,1,1,0,1,0,0]],IndexVal 1], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_p16(UINT64_C(0x2c4f77ac49e91f49));
      clear_neon_saturated();
      //  Expect: "result" = 49e949e949e949e949e949e949e949e9
      result = vdupq_lane_p16(arg1, 1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p16(result), 0);
         exp = UINT64_C(0x49e949e949e949e9);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p16(result), 1);
         exp = UINT64_C(0x49e949e949e949e9);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1932() {

{
   {
      float32x2_t arg1;
      float32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"set_all_lanes_lane\", fnname = \"vdupq_lane_f32\", rettype = \"float32x4_t\", argtypes = \"[float32x2_t,__constrange(0,1) int]\", vals = [VectorVal [FloatVal 0.6754792332649231,FloatVal 0.2056260108947754],IndexVal 0], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_f32(UINT64_C(0x3e528fa03f2cec35));
      clear_neon_saturated();
      //  Expect: "result" = 3f2cec353f2cec353f2cec353f2cec35
      result = vdupq_lane_f32(arg1, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 0);
         exp = ((float32_t) 0.6754792332649231);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 1);
         exp = ((float32_t) 0.6754792332649231);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 2);
         exp = ((float32_t) 0.6754792332649231);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 2 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 3);
         exp = ((float32_t) 0.6754792332649231);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 3 ", exp, got);
            }
      }
   }
}
}
void dotests_1933() {

{
   {
      int64x1_t arg1;
      int64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"set_all_lanes_lane\", fnname = \"vdupq_lane_s64\", rettype = \"int64x2_t\", argtypes = \"[int64x1_t,__constrange(0,0) int]\", vals = [VectorVal [IntegerVal (-1765551791417556993)],IndexVal 0], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_s64(UINT64_C(0xe77f800000007fff));
      clear_neon_saturated();
      //  Expect: "result" = e77f800000007fffe77f800000007fff
      result = vdupq_lane_s64(arg1, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 0);
         exp = UINT64_C(0xe77f800000007fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 1);
         exp = UINT64_C(0xe77f800000007fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1934() {

{
   {
      uint64x1_t arg1;
      uint64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"set_all_lanes_lane\", fnname = \"vdupq_lane_u64\", rettype = \"uint64x2_t\", argtypes = \"[uint64x1_t,__constrange(0,0) int]\", vals = [VectorVal [IntegerVal 9223285860483530751],IndexVal 0], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_u64(UINT64_C(0x7fffb19f8000ffff));
      clear_neon_saturated();
      //  Expect: "result" = 7fffb19f8000ffff7fffb19f8000ffff
      result = vdupq_lane_u64(arg1, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 0);
         exp = UINT64_C(0x7fffb19f8000ffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 1);
         exp = UINT64_C(0x7fffb19f8000ffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1935() {

{
   {
      float64x1_t arg1;
      float64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"set_all_lanes_lane\", fnname = \"vdupq_lane_f64\", rettype = \"float64x2_t\", argtypes = \"[float64x1_t,__constrange(0,0) int]\", vals = [VectorVal [FloatVal 0.22968258531566377],IndexVal 0], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_f64(UINT64_C(0x3fcd663d2c321cdc));
      clear_neon_saturated();
      //  Expect: "result" = 3fcd663d2c321cdc3fcd663d2c321cdc
      result = vdupq_lane_f64(arg1, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float64_t got;
         float64_t exp;
         got = vgetq_lane_f64(result, 0);
         exp = 0.22968258531566377;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float64_t got;
         float64_t exp;
         got = vgetq_lane_f64(result, 1);
         exp = 0.22968258531566377;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
   }
}
}
void dotests_1936() {

{
   {
      poly64x1_t arg1;
      poly64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"set_all_lanes_lane\", fnname = \"vdupq_lane_p64\", rettype = \"poly64x2_t\", argtypes = \"[poly64x1_t,__constrange(0,0) int]\", vals = [VectorVal [PolyVal [0,1,1,1,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,1,0,1,0,1,0,1,0,1,0,1,1,1,0,1,1,1,0,1,0,1,1,0,0,1,1,1,1,0,0,1,1,1,1,0,1,0,0,1]],IndexVal 0], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_p64(UINT64_C(0x979e6bbaab420a4e));
      clear_neon_saturated();
      //  Expect: "result" = 979e6bbaab420a4e979e6bbaab420a4e
      result = vdupq_lane_p64(arg1, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p64(result), 0);
         exp = UINT64_C(0x979e6bbaab420a4e);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p64(result), 1);
         exp = UINT64_C(0x979e6bbaab420a4e);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1937() {

{
   {
      uint8x16_t arg1;
      uint8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"set_all_lanes_lane\", fnname = \"vdup_laneq_u8\", rettype = \"uint8x8_t\", argtypes = \"[uint8x16_t,__constrange(0,15) int]\", vals = [VectorVal [IntegerVal 176,IntegerVal 207,IntegerVal 127,IntegerVal 127,IntegerVal 241,IntegerVal 128,IntegerVal 127,IntegerVal 128,IntegerVal 157,IntegerVal 207,IntegerVal 0,IntegerVal 0,IntegerVal 0,IntegerVal 128,IntegerVal 128,IntegerVal 178],IndexVal 5], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcombine_u8(vcreate_u8(UINT64_C(0x807f80f17f7fcfb0)),
                         vcreate_u8(UINT64_C(0xb28080000000cf9d)));
      clear_neon_saturated();
      //  Expect: "result" = 8080808080808080
      result = vdup_laneq_u8(arg1, 5);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u8(result), 0);
      exp = UINT64_C(0x8080808080808080);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1938() {

{
   {
      uint16x8_t arg1;
      uint16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"set_all_lanes_lane\", fnname = \"vdup_laneq_u16\", rettype = \"uint16x4_t\", argtypes = \"[uint16x8_t,__constrange(0,7) int]\", vals = [VectorVal [IntegerVal 0,IntegerVal 32767,IntegerVal 0,IntegerVal 32768,IntegerVal 65535,IntegerVal 14583,IntegerVal 65535,IntegerVal 32767],IndexVal 7], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcombine_u16(vcreate_u16(UINT64_C(0x800000007fff0000)),
                          vcreate_u16(UINT64_C(0x7fffffff38f7ffff)));
      clear_neon_saturated();
      //  Expect: "result" = 7fff7fff7fff7fff
      result = vdup_laneq_u16(arg1, 7);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u16(result), 0);
      exp = UINT64_C(0x7fff7fff7fff7fff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1939() {

{
   {
      uint32x4_t arg1;
      uint32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"set_all_lanes_lane\", fnname = \"vdup_laneq_u32\", rettype = \"uint32x2_t\", argtypes = \"[uint32x4_t,__constrange(0,3) int]\", vals = [VectorVal [IntegerVal 2147494860,IntegerVal 2147549183,IntegerVal 2147483647,IntegerVal 2147450880],IndexVal 0], start_saturated = True}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcombine_u32(vcreate_u32(UINT64_C(0x8000ffff80002bcc)),
                          vcreate_u32(UINT64_C(0x7fff80007fffffff)));
      set_neon_saturated();
      //  Expect: "result" = 80002bcc80002bcc
      result = vdup_laneq_u32(arg1, 0);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u32(result), 0);
      exp = UINT64_C(0x80002bcc80002bcc);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1940() {

{
   {
      uint64x2_t arg1;
      uint64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"set_all_lanes_lane\", fnname = \"vdup_laneq_u64\", rettype = \"uint64x1_t\", argtypes = \"[uint64x2_t,__constrange(0,1) int]\", vals = [VectorVal [IntegerVal 9223276922656587775,IntegerVal 18446603336221163519],IndexVal 0], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcombine_u64(vcreate_u64(UINT64_C(0x7fffa97e8000ffff)),
                          vcreate_u64(UINT64_C(0xffff7fffffff7fff)));
      clear_neon_saturated();
      //  Expect: "result" = 7fffa97e8000ffff
      result = vdup_laneq_u64(arg1, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(result, 0);
      exp = UINT64_C(0x7fffa97e8000ffff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1941() {

{
   {
      int8x16_t arg1;
      int8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"set_all_lanes_lane\", fnname = \"vdup_laneq_s8\", rettype = \"int8x8_t\", argtypes = \"[int8x16_t,__constrange(0,15) int]\", vals = [VectorVal [IntegerVal (-1),IntegerVal (-1),IntegerVal (-36),IntegerVal (-1),IntegerVal 0,IntegerVal 0,IntegerVal 0,IntegerVal (-1),IntegerVal 32,IntegerVal 0,IntegerVal (-1),IntegerVal 0,IntegerVal 127,IntegerVal (-1),IntegerVal (-128),IntegerVal (-1)],IndexVal 8], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcombine_s8(vcreate_s8(UINT64_C(0xff000000ffdcffff)),
                         vcreate_s8(UINT64_C(0xff80ff7f00ff0020)));
      clear_neon_saturated();
      //  Expect: "result" = 2020202020202020
      result = vdup_laneq_s8(arg1, 8);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s8(result), 0);
      exp = UINT64_C(0x2020202020202020);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1942() {

{
   {
      int16x8_t arg1;
      int16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"set_all_lanes_lane\", fnname = \"vdup_laneq_s16\", rettype = \"int16x4_t\", argtypes = \"[int16x8_t,__constrange(0,7) int]\", vals = [VectorVal [IntegerVal (-32768),IntegerVal 0,IntegerVal 0,IntegerVal (-1),IntegerVal 0,IntegerVal 0,IntegerVal 32767,IntegerVal (-2489)],IndexVal 1], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcombine_s16(vcreate_s16(UINT64_C(0xffff000000008000)),
                          vcreate_s16(UINT64_C(0xf6477fff00000000)));
      clear_neon_saturated();
      //  Expect: "result" = 0000000000000000
      result = vdup_laneq_s16(arg1, 1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s16(result), 0);
      exp = 0;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1943() {

{
   {
      int32x4_t arg1;
      int32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"set_all_lanes_lane\", fnname = \"vdup_laneq_s32\", rettype = \"int32x2_t\", argtypes = \"[int32x4_t,__constrange(0,3) int]\", vals = [VectorVal [IntegerVal (-32769),IntegerVal 649723903,IntegerVal 2147418112,IntegerVal 2147418112],IndexVal 2], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcombine_s32(vcreate_s32(UINT64_C(0x26b9ffffffff7fff)),
                          vcreate_s32(UINT64_C(0x7fff00007fff0000)));
      clear_neon_saturated();
      //  Expect: "result" = 7fff00007fff0000
      result = vdup_laneq_s32(arg1, 2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s32(result), 0);
      exp = UINT64_C(0x7fff00007fff0000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1944() {

{
   {
      int64x2_t arg1;
      int64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"set_all_lanes_lane\", fnname = \"vdup_laneq_s64\", rettype = \"int64x1_t\", argtypes = \"[int64x2_t,__constrange(0,1) int]\", vals = [VectorVal [IntegerVal 9223372034707324928,IntegerVal 8396539294914707456],IndexVal 0], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcombine_s64(vcreate_s64(UINT64_C(0x7fffffff80008000)),
                          vcreate_s64(UINT64_C(0x7486800080000000)));
      clear_neon_saturated();
      //  Expect: "result" = 7fffffff80008000
      result = vdup_laneq_s64(arg1, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s64(result), 0);
      exp = UINT64_C(0x7fffffff80008000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1945() {

{
   {
      poly8x16_t arg1;
      poly8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"set_all_lanes_lane\", fnname = \"vdup_laneq_p8\", rettype = \"poly8x8_t\", argtypes = \"[poly8x16_t,__constrange(0,15) int]\", vals = [VectorVal [PolyVal [0,1,0,1,1,0,0,1],PolyVal [1,0,0,0,0,1,1,0],PolyVal [0,1,0,1,1,1,1,0],PolyVal [1,0,0,0,1,0,1,1],PolyVal [1,0,0,1,0,1,1,1],PolyVal [0,1,1,0,0,0,0,1],PolyVal [1,1,0,1,0,0,0,0],PolyVal [0,1,1,0,1,1,0,0],PolyVal [0,0,1,1,1,1,0,1],PolyVal [1,1,0,0,0,0,0,1],PolyVal [0,1,1,0,1,0,1,1],PolyVal [1,0,1,0,0,0,0,0],PolyVal [1,0,1,0,0,1,1,0],PolyVal [0,0,1,0,0,0,0,1],PolyVal [0,0,1,1,0,1,1,0],PolyVal [1,0,1,0,1,1,0,1]],IndexVal 8], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcombine_p8(vcreate_p8(UINT64_C(0x360b86e9d17a619a)),
                         vcreate_p8(UINT64_C(0xb56c846505d683bc)));
      clear_neon_saturated();
      //  Expect: "result" = bcbcbcbcbcbcbcbc
      result = vdup_laneq_p8(arg1, 8);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_p8(result), 0);
      exp = UINT64_C(0xbcbcbcbcbcbcbcbc);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1946() {

{
   {
      poly16x8_t arg1;
      poly16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"set_all_lanes_lane\", fnname = \"vdup_laneq_p16\", rettype = \"poly16x4_t\", argtypes = \"[poly16x8_t,__constrange(0,7) int]\", vals = [VectorVal [PolyVal [0,1,0,1,1,1,1,1,1,0,1,0,0,1,0,0],PolyVal [1,0,1,1,1,1,0,0,1,0,1,1,0,1,0,0],PolyVal [0,1,0,0,1,1,1,0,1,1,1,1,0,0,1,0],PolyVal [0,1,1,1,0,1,1,1,1,1,0,1,1,0,1,0],PolyVal [0,0,1,0,0,1,1,0,1,0,0,0,1,0,1,1],PolyVal [0,1,1,0,1,0,0,0,0,1,1,0,0,1,0,1],PolyVal [0,0,1,0,1,0,0,1,0,0,1,1,1,1,1,1],PolyVal [0,0,0,0,1,1,1,0,1,1,0,1,0,0,0,1]],IndexVal 5], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcombine_p16(vcreate_p16(UINT64_C(0x5bee4f722d3d25fa)),
                          vcreate_p16(UINT64_C(0x8b70fc94a616d164)));
      clear_neon_saturated();
      //  Expect: "result" = a616a616a616a616
      result = vdup_laneq_p16(arg1, 5);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_p16(result), 0);
      exp = UINT64_C(0xa616a616a616a616);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1947() {

{
   {
      float32x4_t arg1;
      float32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"set_all_lanes_lane\", fnname = \"vdup_laneq_f32\", rettype = \"float32x2_t\", argtypes = \"[float32x4_t,__constrange(0,3) int]\", vals = [VectorVal [FloatVal 0.2331451177597046,FloatVal 3.883802890777588e-2,FloatVal 0.5976652503013611,FloatVal 0.49725157022476196],IndexVal 3], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_f32(vcreate_f32(UINT64_C(0x3d1f14a03e6ebd98)),
                          vcreate_f32(UINT64_C(0x3efe97c23f190097)));
      clear_neon_saturated();
      //  Expect: "result" = 3efe97c23efe97c2
      result = vdup_laneq_f32(arg1, 3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result, 0);
         exp = ((float32_t) 0.49725157022476196);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result, 1);
         exp = ((float32_t) 0.49725157022476196);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
   }
}
}
void dotests_1948() {

{
   {
      float64x2_t arg1;
      float64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"set_all_lanes_lane\", fnname = \"vdup_laneq_f64\", rettype = \"float64x1_t\", argtypes = \"[float64x2_t,__constrange(0,1) int]\", vals = [VectorVal [FloatVal 9.642495782666127e-2,FloatVal 0.670647460577259],IndexVal 1], start_saturated = False}";
      int reported = 0;
      float64_t got;
      float64_t exp;
      arg1 = vcombine_f64(vcreate_f64(UINT64_C(0x3fb8af4e58623978)),
                          vcreate_f64(UINT64_C(0x3fe575f1a9ca6492)));
      clear_neon_saturated();
      //  Expect: "result" = 3fe575f1a9ca6492
      result = vdup_laneq_f64(arg1, 1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_f64(result, 0);
      exp = 0.670647460577259;
      if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
         }
   }
}
}
void dotests_1949() {

{
   {
      poly64x2_t arg1;
      poly64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"set_all_lanes_lane\", fnname = \"vdup_laneq_p64\", rettype = \"poly64x1_t\", argtypes = \"[poly64x2_t,__constrange(0,1) int]\", vals = [VectorVal [PolyVal [1,0,1,1,0,1,0,1,0,1,1,1,0,0,0,1,1,0,1,1,0,0,1,1,0,0,1,1,0,0,1,0,0,0,1,1,0,1,1,1,0,0,0,1,0,1,1,1,1,0,1,1,0,1,0,0,0,1,0,0,0,0,0,1],PolyVal [1,0,1,1,0,1,1,1,1,0,1,1,0,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,1,1,0,0,1,0,0,0,0,1,1,1,1,0,1,0,0,0,0,1,1,0,1,1,1,1,1,0,1,1,0,0,1,1]],IndexVal 1], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcombine_p64(vcreate_p64(UINT64_C(0x822de8ec4ccd8ead)),
                          vcreate_p64(UINT64_C(0xcdf61784c2110ded)));
      clear_neon_saturated();
      //  Expect: "result" = cdf61784c2110ded
      result = vdup_laneq_p64(arg1, 1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_p64(result), 0);
      exp = UINT64_C(0xcdf61784c2110ded);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1950() {

{
   {
      uint8x16_t arg1;
      uint8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"set_all_lanes_lane\", fnname = \"vdupq_laneq_u8\", rettype = \"uint8x16_t\", argtypes = \"[uint8x16_t,__constrange(0,15) int]\", vals = [VectorVal [IntegerVal 127,IntegerVal 0,IntegerVal 127,IntegerVal 0,IntegerVal 128,IntegerVal 127,IntegerVal 0,IntegerVal 128,IntegerVal 0,IntegerVal 204,IntegerVal 255,IntegerVal 128,IntegerVal 132,IntegerVal 85,IntegerVal 255,IntegerVal 0],IndexVal 2], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u8(vcreate_u8(UINT64_C(0x80007f80007f007f)),
                         vcreate_u8(UINT64_C(0x00ff558480ffcc00)));
      clear_neon_saturated();
      //  Expect: "result" = 7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f
      result = vdupq_laneq_u8(arg1, 2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 0);
         exp = UINT64_C(0x7f7f7f7f7f7f7f7f);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 1);
         exp = UINT64_C(0x7f7f7f7f7f7f7f7f);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1951() {

{
   {
      uint16x8_t arg1;
      uint16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"set_all_lanes_lane\", fnname = \"vdupq_laneq_u16\", rettype = \"uint16x8_t\", argtypes = \"[uint16x8_t,__constrange(0,7) int]\", vals = [VectorVal [IntegerVal 32767,IntegerVal 32768,IntegerVal 32767,IntegerVal 0,IntegerVal 32767,IntegerVal 0,IntegerVal 32768,IntegerVal 32768],IndexVal 1], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u16(vcreate_u16(UINT64_C(0x00007fff80007fff)),
                          vcreate_u16(UINT64_C(0x8000800000007fff)));
      clear_neon_saturated();
      //  Expect: "result" = 80008000800080008000800080008000
      result = vdupq_laneq_u16(arg1, 1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 0);
         exp = UINT64_C(0x8000800080008000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 1);
         exp = UINT64_C(0x8000800080008000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1952() {

{
   {
      uint32x4_t arg1;
      uint32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"set_all_lanes_lane\", fnname = \"vdupq_laneq_u32\", rettype = \"uint32x4_t\", argtypes = \"[uint32x4_t,__constrange(0,3) int]\", vals = [VectorVal [IntegerVal 2147516416,IntegerVal 4294967295,IntegerVal 2147516415,IntegerVal 2992340991],IndexVal 2], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u32(vcreate_u32(UINT64_C(0xffffffff80008000)),
                          vcreate_u32(UINT64_C(0xb25b7fff80007fff)));
      clear_neon_saturated();
      //  Expect: "result" = 80007fff80007fff80007fff80007fff
      result = vdupq_laneq_u32(arg1, 2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 0);
         exp = UINT64_C(0x80007fff80007fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 1);
         exp = UINT64_C(0x80007fff80007fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1953() {

{
   {
      uint64x2_t arg1;
      uint64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"set_all_lanes_lane\", fnname = \"vdupq_laneq_u64\", rettype = \"uint64x2_t\", argtypes = \"[uint64x2_t,__constrange(0,1) int]\", vals = [VectorVal [IntegerVal 9223231301939724288,IntegerVal 9223231297218871296],IndexVal 1], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u64(vcreate_u64(UINT64_C(0x7fff800099618000)),
                          vcreate_u64(UINT64_C(0x7fff7fff7fff0000)));
      clear_neon_saturated();
      //  Expect: "result" = 7fff7fff7fff00007fff7fff7fff0000
      result = vdupq_laneq_u64(arg1, 1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 0);
         exp = UINT64_C(0x7fff7fff7fff0000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 1);
         exp = UINT64_C(0x7fff7fff7fff0000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1954() {

{
   {
      int8x16_t arg1;
      int8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"set_all_lanes_lane\", fnname = \"vdupq_laneq_s8\", rettype = \"int8x16_t\", argtypes = \"[int8x16_t,__constrange(0,15) int]\", vals = [VectorVal [IntegerVal 127,IntegerVal 0,IntegerVal 0,IntegerVal (-1),IntegerVal (-128),IntegerVal 0,IntegerVal 127,IntegerVal 127,IntegerVal 127,IntegerVal 127,IntegerVal (-1),IntegerVal (-1),IntegerVal 127,IntegerVal (-98),IntegerVal (-97),IntegerVal (-128)],IndexVal 12], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s8(vcreate_s8(UINT64_C(0x7f7f0080ff00007f)),
                         vcreate_s8(UINT64_C(0x809f9e7fffff7f7f)));
      clear_neon_saturated();
      //  Expect: "result" = 7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f
      result = vdupq_laneq_s8(arg1, 12);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result), 0);
         exp = UINT64_C(0x7f7f7f7f7f7f7f7f);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result), 1);
         exp = UINT64_C(0x7f7f7f7f7f7f7f7f);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1955() {

{
   {
      int16x8_t arg1;
      int16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"set_all_lanes_lane\", fnname = \"vdupq_laneq_s16\", rettype = \"int16x8_t\", argtypes = \"[int16x8_t,__constrange(0,7) int]\", vals = [VectorVal [IntegerVal (-32768),IntegerVal (-1),IntegerVal 0,IntegerVal 14754,IntegerVal 0,IntegerVal (-6257),IntegerVal 7534,IntegerVal 0],IndexVal 6], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s16(vcreate_s16(UINT64_C(0x39a20000ffff8000)),
                          vcreate_s16(UINT64_C(0x00001d6ee78f0000)));
      clear_neon_saturated();
      //  Expect: "result" = 1d6e1d6e1d6e1d6e1d6e1d6e1d6e1d6e
      result = vdupq_laneq_s16(arg1, 6);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 0);
         exp = UINT64_C(0x1d6e1d6e1d6e1d6e);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 1);
         exp = UINT64_C(0x1d6e1d6e1d6e1d6e);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1956() {

{
   {
      int32x4_t arg1;
      int32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"set_all_lanes_lane\", fnname = \"vdupq_laneq_s32\", rettype = \"int32x4_t\", argtypes = \"[int32x4_t,__constrange(0,3) int]\", vals = [VectorVal [IntegerVal (-2147418113),IntegerVal 2147450880,IntegerVal (-1),IntegerVal (-32769)],IndexVal 3], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s32(vcreate_s32(UINT64_C(0x7fff80008000ffff)),
                          vcreate_s32(UINT64_C(0xffff7fffffffffff)));
      clear_neon_saturated();
      //  Expect: "result" = ffff7fffffff7fffffff7fffffff7fff
      result = vdupq_laneq_s32(arg1, 3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 0);
         exp = UINT64_C(0xffff7fffffff7fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 1);
         exp = UINT64_C(0xffff7fffffff7fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1957() {

{
   {
      int64x2_t arg1;
      int64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"set_all_lanes_lane\", fnname = \"vdupq_laneq_s64\", rettype = \"int64x2_t\", argtypes = \"[int64x2_t,__constrange(0,1) int]\", vals = [VectorVal [IntegerVal 9223372034707357695,IntegerVal 6755983589376],IndexVal 0], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s64(vcreate_s64(UINT64_C(0x7fffffff8000ffff)),
                          vcreate_s64(UINT64_C(0x0000062500008000)));
      clear_neon_saturated();
      //  Expect: "result" = 7fffffff8000ffff7fffffff8000ffff
      result = vdupq_laneq_s64(arg1, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 0);
         exp = UINT64_C(0x7fffffff8000ffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 1);
         exp = UINT64_C(0x7fffffff8000ffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1958() {

{
   {
      poly8x16_t arg1;
      poly8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"set_all_lanes_lane\", fnname = \"vdupq_laneq_p8\", rettype = \"poly8x16_t\", argtypes = \"[poly8x16_t,__constrange(0,15) int]\", vals = [VectorVal [PolyVal [1,1,0,1,1,0,0,0],PolyVal [0,1,0,0,0,0,0,1],PolyVal [0,1,1,0,0,1,0,1],PolyVal [1,0,1,1,0,0,0,0],PolyVal [0,0,1,0,0,1,1,0],PolyVal [0,0,0,0,1,0,1,1],PolyVal [1,1,1,1,1,1,1,1],PolyVal [0,0,0,0,0,1,0,0],PolyVal [1,0,0,1,1,1,1,1],PolyVal [1,0,0,1,0,1,1,1],PolyVal [1,1,0,0,0,1,1,1],PolyVal [0,0,0,1,0,0,0,1],PolyVal [1,1,0,1,1,1,1,1],PolyVal [1,1,0,1,0,0,0,0],PolyVal [1,1,0,1,1,0,1,0],PolyVal [1,1,1,0,1,1,0,1]],IndexVal 13], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_p8(vcreate_p8(UINT64_C(0x20ffd0640da6821b)),
                         vcreate_p8(UINT64_C(0xb75b0bfb88e3e9f9)));
      clear_neon_saturated();
      //  Expect: "result" = 0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b
      result = vdupq_laneq_p8(arg1, 13);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p8(result), 0);
         exp = UINT64_C(0x0b0b0b0b0b0b0b0b);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p8(result), 1);
         exp = UINT64_C(0x0b0b0b0b0b0b0b0b);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1959() {

{
   {
      poly16x8_t arg1;
      poly16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"set_all_lanes_lane\", fnname = \"vdupq_laneq_p16\", rettype = \"poly16x8_t\", argtypes = \"[poly16x8_t,__constrange(0,7) int]\", vals = [VectorVal [PolyVal [1,0,0,1,0,0,0,1,0,1,1,0,1,0,1,0],PolyVal [0,0,0,1,0,0,1,1,1,1,1,1,1,1,0,1],PolyVal [1,1,0,1,0,0,0,0,0,1,1,0,0,1,0,0],PolyVal [1,0,1,1,1,0,0,1,1,1,1,0,0,0,0,0],PolyVal [1,0,0,1,1,0,0,0,1,1,0,1,0,1,0,0],PolyVal [0,0,1,1,1,0,1,1,1,0,1,1,1,1,1,0],PolyVal [1,0,0,1,0,0,1,1,0,1,0,1,1,0,0,0],PolyVal [0,1,0,0,1,0,1,1,1,0,0,0,1,0,1,0]],IndexVal 4], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_p16(vcreate_p16(UINT64_C(0x079d260bbfc85689)),
                          vcreate_p16(UINT64_C(0x51d21ac97ddc2b19)));
      clear_neon_saturated();
      //  Expect: "result" = 2b192b192b192b192b192b192b192b19
      result = vdupq_laneq_p16(arg1, 4);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p16(result), 0);
         exp = UINT64_C(0x2b192b192b192b19);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p16(result), 1);
         exp = UINT64_C(0x2b192b192b192b19);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1960() {

{
   {
      float32x4_t arg1;
      float32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"set_all_lanes_lane\", fnname = \"vdupq_laneq_f32\", rettype = \"float32x4_t\", argtypes = \"[float32x4_t,__constrange(0,3) int]\", vals = [VectorVal [FloatVal 0.22697842121124268,FloatVal 0.9305213093757629,FloatVal 0.7316967248916626,FloatVal 1.3947010040283203e-2],IndexVal 3], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_f32(vcreate_f32(UINT64_C(0x3f6e36a53e686d08)),
                          vcreate_f32(UINT64_C(0x3c6482003f3b507a)));
      clear_neon_saturated();
      //  Expect: "result" = 3c6482003c6482003c6482003c648200
      result = vdupq_laneq_f32(arg1, 3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 0);
         exp = ((float32_t) 1.3947010040283203e-2);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 1);
         exp = ((float32_t) 1.3947010040283203e-2);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 2);
         exp = ((float32_t) 1.3947010040283203e-2);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 2 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 3);
         exp = ((float32_t) 1.3947010040283203e-2);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 3 ", exp, got);
            }
      }
   }
}
}
void dotests_1961() {

{
   {
      float64x2_t arg1;
      float64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"set_all_lanes_lane\", fnname = \"vdupq_laneq_f64\", rettype = \"float64x2_t\", argtypes = \"[float64x2_t,__constrange(0,1) int]\", vals = [VectorVal [FloatVal 0.955800074210333,FloatVal 0.26400092009761544],IndexVal 1], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_f64(vcreate_f64(UINT64_C(0x3fee95ea0987ed98)),
                          vcreate_f64(UINT64_C(0x3fd0e5641d7bb904)));
      clear_neon_saturated();
      //  Expect: "result" = 3fd0e5641d7bb9043fd0e5641d7bb904
      result = vdupq_laneq_f64(arg1, 1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float64_t got;
         float64_t exp;
         got = vgetq_lane_f64(result, 0);
         exp = 0.26400092009761544;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float64_t got;
         float64_t exp;
         got = vgetq_lane_f64(result, 1);
         exp = 0.26400092009761544;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
   }
}
}
void dotests_1962() {

{
   {
      poly64x2_t arg1;
      poly64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"set_all_lanes_lane\", fnname = \"vdupq_laneq_p64\", rettype = \"poly64x2_t\", argtypes = \"[poly64x2_t,__constrange(0,1) int]\", vals = [VectorVal [PolyVal [0,1,1,0,1,1,1,1,1,1,0,1,1,1,1,1,1,0,1,0,1,0,1,1,0,1,1,1,0,1,0,0,1,1,1,1,1,1,0,1,1,0,1,1,1,1,0,0,1,0,1,1,1,1,1,0,1,1,0,1,1,1,0,1],PolyVal [1,1,1,0,1,1,1,0,1,1,0,1,1,0,1,1,0,0,0,1,1,1,1,0,1,0,1,1,1,1,1,1,1,1,0,0,0,0,1,0,0,1,1,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,1,0,1,1,0,0]],IndexVal 0], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_p64(vcreate_p64(UINT64_C(0xbb7d3dbf2ed5fbf6)),
                          vcreate_p64(UINT64_C(0x36488643fd78db77)));
      clear_neon_saturated();
      //  Expect: "result" = bb7d3dbf2ed5fbf6bb7d3dbf2ed5fbf6
      result = vdupq_laneq_p64(arg1, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p64(result), 0);
         exp = UINT64_C(0xbb7d3dbf2ed5fbf6);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p64(result), 1);
         exp = UINT64_C(0xbb7d3dbf2ed5fbf6);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1963() {

{
   {
      int64x1_t arg1;
      int64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"set_all_lanes_lane\", fnname = \"vdup_lane_s64\", rettype = \"int64x1_t\", argtypes = \"[int64x1_t,__constrange(0,0) int]\", vals = [VectorVal [IntegerVal (-281474976677889)],IndexVal 0], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s64(UINT64_C(0xffff000000007fff));
      clear_neon_saturated();
      //  Expect: "result" = ffff000000007fff
      result = vdup_lane_s64(arg1, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s64(result), 0);
      exp = UINT64_C(0xffff000000007fff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1964() {

{
   {
      uint64x1_t arg1;
      uint64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"set_all_lanes_lane\", fnname = \"vdup_lane_u64\", rettype = \"uint64x1_t\", argtypes = \"[uint64x1_t,__constrange(0,0) int]\", vals = [VectorVal [IntegerVal 9223632073502268847],IndexVal 0], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u64(UINT64_C(0x8000ec8080009daf));
      clear_neon_saturated();
      //  Expect: "result" = 8000ec8080009daf
      result = vdup_lane_u64(arg1, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(result, 0);
      exp = UINT64_C(0x8000ec8080009daf);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1965() {

{
   {
      poly64x1_t arg1;
      poly64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"set_all_lanes_lane\", fnname = \"vdup_lane_p64\", rettype = \"poly64x1_t\", argtypes = \"[poly64x1_t,__constrange(0,0) int]\", vals = [VectorVal [PolyVal [0,0,1,1,0,1,0,1,0,1,1,1,0,1,0,0,0,0,0,1,1,1,0,1,1,1,1,0,1,1,0,0,1,1,0,0,0,0,1,0,0,1,1,1,1,0,1,1,1,1,0,0,1,1,1,1,1,0,1,1,0,1,0,1]],IndexVal 0], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_p64(UINT64_C(0xadf3de4337b82eac));
      clear_neon_saturated();
      //  Expect: "result" = adf3de4337b82eac
      result = vdup_lane_p64(arg1, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_p64(result), 0);
      exp = UINT64_C(0xadf3de4337b82eac);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1966() {

{
   {
      uint8x8_t arg1;
      uint8_t result;
      char* str1 = "ReproInfo2 {semantics = \"set_all_lanes_lane\", fnname = \"vdupb_lane_u8\", rettype = \"uint8_t\", argtypes = \"[uint8x8_t,__constrange(0,7) int]\", vals = [VectorVal [IntegerVal 128,IntegerVal 128,IntegerVal 128,IntegerVal 127,IntegerVal 230,IntegerVal 128,IntegerVal 127,IntegerVal 255],IndexVal 6], start_saturated = False}";
      int reported = 0;
      uint8_t got;
      uint8_t exp;
      arg1 = vcreate_u8(UINT64_C(0xff7f80e67f808080));
      clear_neon_saturated();
      //  Expect: "result" = 7f
      result = vdupb_lane_u8(arg1, 6);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = 127U;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1967() {

{
   {
      uint16x4_t arg1;
      uint16_t result;
      char* str1 = "ReproInfo2 {semantics = \"set_all_lanes_lane\", fnname = \"vduph_lane_u16\", rettype = \"uint16_t\", argtypes = \"[uint16x4_t,__constrange(0,3) int]\", vals = [VectorVal [IntegerVal 32767,IntegerVal 11796,IntegerVal 32767,IntegerVal 32767],IndexVal 3], start_saturated = False}";
      int reported = 0;
      uint16_t got;
      uint16_t exp;
      arg1 = vcreate_u16(UINT64_C(0x7fff7fff2e147fff));
      clear_neon_saturated();
      //  Expect: "result" = 7fff
      result = vduph_lane_u16(arg1, 3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = 32767U;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1968() {

{
   {
      uint32x2_t arg1;
      uint32_t result;
      char* str1 = "ReproInfo2 {semantics = \"set_all_lanes_lane\", fnname = \"vdups_lane_u32\", rettype = \"uint32_t\", argtypes = \"[uint32x2_t,__constrange(0,1) int]\", vals = [VectorVal [IntegerVal 2147483647,IntegerVal 484802559],IndexVal 1], start_saturated = False}";
      int reported = 0;
      uint32_t got;
      uint32_t exp;
      arg1 = vcreate_u32(UINT64_C(0x1ce57fff7fffffff));
      clear_neon_saturated();
      //  Expect: "result" = 1ce57fff
      result = vdups_lane_u32(arg1, 1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = 484802559U;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIu32 " Got: %" PRIu32 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1969() {

{
   {
      uint64x1_t arg1;
      uint64_t result;
      char* str1 = "ReproInfo2 {semantics = \"set_all_lanes_lane\", fnname = \"vdupd_lane_u64\", rettype = \"uint64_t\", argtypes = \"[uint64x1_t,__constrange(0,0) int]\", vals = [VectorVal [IntegerVal 18446603334073712639],IndexVal 0], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u64(UINT64_C(0xffff7fff7fffffff));
      clear_neon_saturated();
      //  Expect: "result" = ffff7fff7fffffff
      result = vdupd_lane_u64(arg1, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = UINT64_C(0xffff7fff7fffffff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1970() {

{
   {
      int8x8_t arg1;
      int8_t result;
      char* str1 = "ReproInfo2 {semantics = \"set_all_lanes_lane\", fnname = \"vdupb_lane_s8\", rettype = \"int8_t\", argtypes = \"[int8x8_t,__constrange(0,7) int]\", vals = [VectorVal [IntegerVal 0,IntegerVal (-128),IntegerVal (-128),IntegerVal (-20),IntegerVal (-4),IntegerVal (-125),IntegerVal 0,IntegerVal 120],IndexVal 2], start_saturated = False}";
      int reported = 0;
      int8_t got;
      int8_t exp;
      arg1 = vcreate_s8(UINT64_C(0x780083fcec808000));
      clear_neon_saturated();
      //  Expect: "result" = 80
      result = vdupb_lane_s8(arg1, 2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = -128;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1971() {

{
   {
      int16x4_t arg1;
      int16_t result;
      char* str1 = "ReproInfo2 {semantics = \"set_all_lanes_lane\", fnname = \"vduph_lane_s16\", rettype = \"int16_t\", argtypes = \"[int16x4_t,__constrange(0,3) int]\", vals = [VectorVal [IntegerVal (-1),IntegerVal 32767,IntegerVal (-1),IntegerVal (-1)],IndexVal 1], start_saturated = False}";
      int reported = 0;
      int16_t got;
      int16_t exp;
      arg1 = vcreate_s16(UINT64_C(0xffffffff7fffffff));
      clear_neon_saturated();
      //  Expect: "result" = 7fff
      result = vduph_lane_s16(arg1, 1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = 32767;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIi16 " Got: %" PRIi16 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1972() {

{
   {
      int32x2_t arg1;
      int32_t result;
      char* str1 = "ReproInfo2 {semantics = \"set_all_lanes_lane\", fnname = \"vdups_lane_s32\", rettype = \"int32_t\", argtypes = \"[int32x2_t,__constrange(0,1) int]\", vals = [VectorVal [IntegerVal 380214257,IntegerVal 2147477387],IndexVal 0], start_saturated = True}";
      int reported = 0;
      int32_t got;
      int32_t exp;
      arg1 = vcreate_s32(UINT64_C(0x7fffe78b16a99bf1));
      set_neon_saturated();
      //  Expect: "result" = 16a99bf1
      result = vdups_lane_s32(arg1, 0);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      got = result;
      exp = 380214257;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIi32 " Got: %" PRIi32 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1973() {

{
   {
      int64x1_t arg1;
      int64_t result;
      char* str1 = "ReproInfo2 {semantics = \"set_all_lanes_lane\", fnname = \"vdupd_lane_s64\", rettype = \"int64_t\", argtypes = \"[int64x1_t,__constrange(0,0) int]\", vals = [VectorVal [IntegerVal 281472829292543],IndexVal 0], start_saturated = False}";
      int reported = 0;
      int64_t got;
      int64_t exp;
      arg1 = vcreate_s64(UINT64_C(0x0000ffff8000ffff));
      clear_neon_saturated();
      //  Expect: "result" = 0000ffff8000ffff
      result = vdupd_lane_s64(arg1, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = INT64_C(281472829292543);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIi64 " Got: %" PRIi64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1974() {

{
   {
      poly8x8_t arg1;
      poly8_t result;
      char* str1 = "ReproInfo2 {semantics = \"set_all_lanes_lane\", fnname = \"vdupb_lane_p8\", rettype = \"poly8_t\", argtypes = \"[poly8x8_t,__constrange(0,7) int]\", vals = [VectorVal [PolyVal [1,0,0,0,1,0,0,1],PolyVal [0,0,1,0,0,1,0,0],PolyVal [0,1,0,1,1,0,1,0],PolyVal [1,0,1,0,1,1,0,1],PolyVal [0,0,1,1,1,0,0,0],PolyVal [1,0,1,0,0,0,1,0],PolyVal [1,0,0,0,0,0,1,0],PolyVal [1,1,0,1,0,1,0,0]],IndexVal 2], start_saturated = False}";
      int reported = 0;
      poly8_t got;
      poly8_t exp;
      arg1 = vcreate_p8(UINT64_C(0x2b41451cb55a2491));
      clear_neon_saturated();
      //  Expect: "result" = 5a
      result = vdupb_lane_p8(arg1, 2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = 90;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1975() {

{
   {
      poly16x4_t arg1;
      poly16_t result;
      char* str1 = "ReproInfo2 {semantics = \"set_all_lanes_lane\", fnname = \"vduph_lane_p16\", rettype = \"poly16_t\", argtypes = \"[poly16x4_t,__constrange(0,3) int]\", vals = [VectorVal [PolyVal [0,1,1,1,0,1,1,1,1,0,0,1,1,1,1,0],PolyVal [0,1,1,1,1,0,1,1,1,0,0,1,1,0,1,1],PolyVal [0,0,0,1,0,1,1,1,1,1,1,0,0,1,1,0],PolyVal [1,0,0,1,0,1,0,1,1,1,1,1,1,0,1,1]],IndexVal 3], start_saturated = False}";
      int reported = 0;
      poly16_t got;
      poly16_t exp;
      arg1 = vcreate_p16(UINT64_C(0xdfa967e8d9de79ee));
      clear_neon_saturated();
      //  Expect: "result" = dfa9
      result = vduph_lane_p16(arg1, 3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = 57257;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1976() {

{
   {
      float32x2_t arg1;
      float32_t result;
      char* str1 = "ReproInfo2 {semantics = \"set_all_lanes_lane\", fnname = \"vdups_lane_f32\", rettype = \"float32_t\", argtypes = \"[float32x2_t,__constrange(0,1) int]\", vals = [VectorVal [FloatVal 0.8004421591758728,FloatVal 0.3505744934082031],IndexVal 0], start_saturated = False}";
      int reported = 0;
      float32_t got;
      float32_t exp;
      arg1 = vcreate_f32(UINT64_C(0x3eb37e803f4ce9c7));
      clear_neon_saturated();
      //  Expect: "result" = 3f4ce9c7
      result = vdups_lane_f32(arg1, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = ((float32_t) 0.8004421591758728);
      if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %f Got: %f\n", "   ", exp, got);
         }
   }
}
}
void dotests_1977() {

{
   {
      float64x1_t arg1;
      float64_t result;
      char* str1 = "ReproInfo2 {semantics = \"set_all_lanes_lane\", fnname = \"vdupd_lane_f64\", rettype = \"float64_t\", argtypes = \"[float64x1_t,__constrange(0,0) int]\", vals = [VectorVal [FloatVal 0.4483153709934773],IndexVal 0], start_saturated = False}";
      int reported = 0;
      float64_t got;
      float64_t exp;
      arg1 = vcreate_f64(UINT64_C(0x3fdcb132f42d8288));
      clear_neon_saturated();
      //  Expect: "result" = 3fdcb132f42d8288
      result = vdupd_lane_f64(arg1, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = 0.4483153709934773;
      if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %f Got: %f\n", "   ", exp, got);
         }
   }
}
}
void dotests_1978() {

{
   {
      uint8x16_t arg1;
      uint8_t result;
      char* str1 = "ReproInfo2 {semantics = \"set_all_lanes_lane\", fnname = \"vdupb_laneq_u8\", rettype = \"uint8_t\", argtypes = \"[uint8x16_t,__constrange(0,15) int]\", vals = [VectorVal [IntegerVal 118,IntegerVal 0,IntegerVal 58,IntegerVal 128,IntegerVal 128,IntegerVal 212,IntegerVal 0,IntegerVal 128,IntegerVal 251,IntegerVal 255,IntegerVal 128,IntegerVal 127,IntegerVal 0,IntegerVal 48,IntegerVal 114,IntegerVal 127],IndexVal 5], start_saturated = False}";
      int reported = 0;
      uint8_t got;
      uint8_t exp;
      arg1 = vcombine_u8(vcreate_u8(UINT64_C(0x8000d480803a0076)),
                         vcreate_u8(UINT64_C(0x7f7230007f80fffb)));
      clear_neon_saturated();
      //  Expect: "result" = d4
      result = vdupb_laneq_u8(arg1, 5);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = 212U;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1979() {

{
   {
      uint16x8_t arg1;
      uint16_t result;
      char* str1 = "ReproInfo2 {semantics = \"set_all_lanes_lane\", fnname = \"vduph_laneq_u16\", rettype = \"uint16_t\", argtypes = \"[uint16x8_t,__constrange(0,7) int]\", vals = [VectorVal [IntegerVal 55110,IntegerVal 32768,IntegerVal 32767,IntegerVal 0,IntegerVal 65535,IntegerVal 65535,IntegerVal 63248,IntegerVal 33585],IndexVal 4], start_saturated = False}";
      int reported = 0;
      uint16_t got;
      uint16_t exp;
      arg1 = vcombine_u16(vcreate_u16(UINT64_C(0x00007fff8000d746)),
                          vcreate_u16(UINT64_C(0x8331f710ffffffff)));
      clear_neon_saturated();
      //  Expect: "result" = ffff
      result = vduph_laneq_u16(arg1, 4);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = 65535U;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1980() {

{
   {
      uint32x4_t arg1;
      uint32_t result;
      char* str1 = "ReproInfo2 {semantics = \"set_all_lanes_lane\", fnname = \"vdups_laneq_u32\", rettype = \"uint32_t\", argtypes = \"[uint32x4_t,__constrange(0,3) int]\", vals = [VectorVal [IntegerVal 2575911743,IntegerVal 4294934527,IntegerVal 32768,IntegerVal 0],IndexVal 1], start_saturated = False}";
      int reported = 0;
      uint32_t got;
      uint32_t exp;
      arg1 = vcombine_u32(vcreate_u32(UINT64_C(0xffff7fff99894b3f)),
                          vcreate_u32(UINT64_C(0x0000000000008000)));
      clear_neon_saturated();
      //  Expect: "result" = ffff7fff
      result = vdups_laneq_u32(arg1, 1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = 4294934527U;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIu32 " Got: %" PRIu32 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1981() {

{
   {
      uint64x2_t arg1;
      uint64_t result;
      char* str1 = "ReproInfo2 {semantics = \"set_all_lanes_lane\", fnname = \"vdupd_laneq_u64\", rettype = \"uint64_t\", argtypes = \"[uint64x2_t,__constrange(0,1) int]\", vals = [VectorVal [IntegerVal 9223231299087335423,IntegerVal 4294901760],IndexVal 1], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcombine_u64(vcreate_u64(UINT64_C(0x7fff7fffef5d7fff)),
                          vcreate_u64(UINT64_C(0x00000000ffff0000)));
      clear_neon_saturated();
      //  Expect: "result" = 00000000ffff0000
      result = vdupd_laneq_u64(arg1, 1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = UINT64_C(0x00000000ffff0000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1982() {

{
   {
      int8x16_t arg1;
      int8_t result;
      char* str1 = "ReproInfo2 {semantics = \"set_all_lanes_lane\", fnname = \"vdupb_laneq_s8\", rettype = \"int8_t\", argtypes = \"[int8x16_t,__constrange(0,15) int]\", vals = [VectorVal [IntegerVal 127,IntegerVal 0,IntegerVal 127,IntegerVal (-1),IntegerVal (-1),IntegerVal 39,IntegerVal 0,IntegerVal (-128),IntegerVal (-96),IntegerVal (-1),IntegerVal (-128),IntegerVal 127,IntegerVal 56,IntegerVal 66,IntegerVal (-1),IntegerVal 127],IndexVal 8], start_saturated = False}";
      int reported = 0;
      int8_t got;
      int8_t exp;
      arg1 = vcombine_s8(vcreate_s8(UINT64_C(0x800027ffff7f007f)),
                         vcreate_s8(UINT64_C(0x7fff42387f80ffa0)));
      clear_neon_saturated();
      //  Expect: "result" = a0
      result = vdupb_laneq_s8(arg1, 8);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = -96;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1983() {

{
   {
      int16x8_t arg1;
      int16_t result;
      char* str1 = "ReproInfo2 {semantics = \"set_all_lanes_lane\", fnname = \"vduph_laneq_s16\", rettype = \"int16_t\", argtypes = \"[int16x8_t,__constrange(0,7) int]\", vals = [VectorVal [IntegerVal 32767,IntegerVal (-1),IntegerVal (-32768),IntegerVal 0,IntegerVal 32767,IntegerVal 0,IntegerVal (-26848),IntegerVal (-32768)],IndexVal 5], start_saturated = False}";
      int reported = 0;
      int16_t got;
      int16_t exp;
      arg1 = vcombine_s16(vcreate_s16(UINT64_C(0x00008000ffff7fff)),
                          vcreate_s16(UINT64_C(0x8000972000007fff)));
      clear_neon_saturated();
      //  Expect: "result" = 0000
      result = vduph_laneq_s16(arg1, 5);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = 0;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIi16 " Got: %" PRIi16 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1984() {

{
   {
      int32x4_t arg1;
      int32_t result;
      char* str1 = "ReproInfo2 {semantics = \"set_all_lanes_lane\", fnname = \"vdups_laneq_s32\", rettype = \"int32_t\", argtypes = \"[int32x4_t,__constrange(0,3) int]\", vals = [VectorVal [IntegerVal 725614591,IntegerVal 2147436007,IntegerVal (-32768),IntegerVal (-876019712)],IndexVal 2], start_saturated = False}";
      int reported = 0;
      int32_t got;
      int32_t exp;
      arg1 = vcombine_s32(vcreate_s32(UINT64_C(0x7fff45e72b3fffff)),
                          vcreate_s32(UINT64_C(0xcbc90000ffff8000)));
      clear_neon_saturated();
      //  Expect: "result" = ffff8000
      result = vdups_laneq_s32(arg1, 2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = -32768;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIi32 " Got: %" PRIi32 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1985() {

{
   {
      int64x2_t arg1;
      int64_t result;
      char* str1 = "ReproInfo2 {semantics = \"set_all_lanes_lane\", fnname = \"vdupd_laneq_s64\", rettype = \"int64_t\", argtypes = \"[int64x2_t,__constrange(0,1) int]\", vals = [VectorVal [IntegerVal 9223198887395688447,IntegerVal (-9223231303661322241)],IndexVal 1], start_saturated = False}";
      int reported = 0;
      int64_t got;
      int64_t exp;
      arg1 = vcombine_s64(vcreate_s64(UINT64_C(0x7fff62857fff7fff)),
                          vcreate_s64(UINT64_C(0x80007fff0000ffff)));
      clear_neon_saturated();
      //  Expect: "result" = 80007fff0000ffff
      result = vdupd_laneq_s64(arg1, 1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = INT64_C(-9223231303661322241);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIi64 " Got: %" PRIi64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1986() {

{
   {
      poly8x16_t arg1;
      poly8_t result;
      char* str1 = "ReproInfo2 {semantics = \"set_all_lanes_lane\", fnname = \"vdupb_laneq_p8\", rettype = \"poly8_t\", argtypes = \"[poly8x16_t,__constrange(0,15) int]\", vals = [VectorVal [PolyVal [0,0,1,1,1,1,1,1],PolyVal [0,1,1,1,1,1,0,1],PolyVal [0,0,1,1,0,0,1,1],PolyVal [0,0,1,1,1,0,1,0],PolyVal [0,0,1,1,0,1,1,0],PolyVal [0,1,1,0,1,0,0,0],PolyVal [1,1,0,1,0,1,0,1],PolyVal [1,1,1,0,0,1,0,0],PolyVal [0,0,0,1,1,0,1,1],PolyVal [1,1,1,0,1,0,1,1],PolyVal [0,1,1,0,1,0,1,1],PolyVal [1,1,1,0,0,0,0,1],PolyVal [0,1,1,0,1,0,1,1],PolyVal [0,0,1,1,1,1,1,0],PolyVal [1,1,0,0,1,0,0,1],PolyVal [1,0,1,1,1,1,0,1]],IndexVal 7], start_saturated = False}";
      int reported = 0;
      poly8_t got;
      poly8_t exp;
      arg1 = vcombine_p8(vcreate_p8(UINT64_C(0x27ab166c5cccbefc)),
                         vcreate_p8(UINT64_C(0xbd937cd687d6d7d8)));
      clear_neon_saturated();
      //  Expect: "result" = 27
      result = vdupb_laneq_p8(arg1, 7);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = 39;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1987() {

{
   {
      poly16x8_t arg1;
      poly16_t result;
      char* str1 = "ReproInfo2 {semantics = \"set_all_lanes_lane\", fnname = \"vduph_laneq_p16\", rettype = \"poly16_t\", argtypes = \"[poly16x8_t,__constrange(0,7) int]\", vals = [VectorVal [PolyVal [0,0,1,0,0,0,1,1,0,0,1,0,1,1,1,0],PolyVal [1,1,0,1,0,0,1,1,1,0,0,1,0,0,1,0],PolyVal [1,1,0,0,0,0,1,1,1,1,0,1,0,0,1,0],PolyVal [0,0,0,0,0,0,0,0,0,1,1,1,0,0,1,0],PolyVal [0,1,0,1,1,0,1,0,0,0,0,1,1,1,1,1],PolyVal [1,0,1,0,0,0,1,1,1,0,0,0,0,0,0,1],PolyVal [1,1,0,0,1,0,1,1,0,1,0,0,1,1,0,0],PolyVal [1,1,1,1,0,0,0,1,0,1,0,0,1,0,1,1]],IndexVal 4], start_saturated = False}";
      int reported = 0;
      poly16_t got;
      poly16_t exp;
      arg1 = vcombine_p16(vcreate_p16(UINT64_C(0x4e004bc349cb74c4)),
                          vcreate_p16(UINT64_C(0xd28f32d381c5f85a)));
      clear_neon_saturated();
      //  Expect: "result" = f85a
      result = vduph_laneq_p16(arg1, 4);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = 63578;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_1988() {

{
   {
      float32x4_t arg1;
      float32_t result;
      char* str1 = "ReproInfo2 {semantics = \"set_all_lanes_lane\", fnname = \"vdups_laneq_f32\", rettype = \"float32_t\", argtypes = \"[float32x4_t,__constrange(0,3) int]\", vals = [VectorVal [FloatVal 0.35688310861587524,FloatVal 0.3522879481315613,FloatVal 0.2253093123435974,FloatVal 0.9103087186813354],IndexVal 3], start_saturated = False}";
      int reported = 0;
      float32_t got;
      float32_t exp;
      arg1 = vcombine_f32(vcreate_f32(UINT64_C(0x3eb45f163eb6b962)),
                          vcreate_f32(UINT64_C(0x3f6909fe3e66b77c)));
      clear_neon_saturated();
      //  Expect: "result" = 3f6909fe
      result = vdups_laneq_f32(arg1, 3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = ((float32_t) 0.9103087186813354);
      if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %f Got: %f\n", "   ", exp, got);
         }
   }
}
}
void dotests_1989() {

{
   {
      float64x2_t arg1;
      float64_t result;
      char* str1 = "ReproInfo2 {semantics = \"set_all_lanes_lane\", fnname = \"vdupd_laneq_f64\", rettype = \"float64_t\", argtypes = \"[float64x2_t,__constrange(0,1) int]\", vals = [VectorVal [FloatVal 0.14705587398707654,FloatVal 0.23274863079181707],IndexVal 1], start_saturated = False}";
      int reported = 0;
      float64_t got;
      float64_t exp;
      arg1 = vcombine_f64(vcreate_f64(UINT64_C(0x3fc2d2ba14bac6c4)),
                          vcreate_f64(UINT64_C(0x3fcdcab506b845e4)));
      clear_neon_saturated();
      //  Expect: "result" = 3fcdcab506b845e4
      result = vdupd_laneq_f64(arg1, 1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = 0.23274863079181707;
      if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %f Got: %f\n", "   ", exp, got);
         }
   }
}
}
void dotests_1990() {

{
   {
      int8x8_t arg1;
      int8x8_t arg2;
      int8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"combine\", fnname = \"vcombine_s8\", rettype = \"int8x16_t\", argtypes = \"[int8x8_t,int8x8_t]\", vals = [VectorVal [IntegerVal (-128),IntegerVal 127,IntegerVal (-1),IntegerVal 65,IntegerVal 127,IntegerVal (-128),IntegerVal 0,IntegerVal (-114)],VectorVal [IntegerVal 0,IntegerVal (-1),IntegerVal 0,IntegerVal (-1),IntegerVal (-128),IntegerVal 127,IntegerVal 0,IntegerVal (-1)]], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_s8(UINT64_C(0x8e00807f41ff7f80));
      arg2 = vcreate_s8(UINT64_C(0xff007f80ff00ff00));
      clear_neon_saturated();
      //  Expect: "result" = ff007f80ff00ff008e00807f41ff7f80
      result = vcombine_s8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result), 0);
         exp = UINT64_C(0x8e00807f41ff7f80);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result), 1);
         exp = UINT64_C(0xff007f80ff00ff00);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1991() {

{
   {
      int16x4_t arg1;
      int16x4_t arg2;
      int16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"combine\", fnname = \"vcombine_s16\", rettype = \"int16x8_t\", argtypes = \"[int16x4_t,int16x4_t]\", vals = [VectorVal [IntegerVal (-32768),IntegerVal 9199,IntegerVal 32767,IntegerVal 0],VectorVal [IntegerVal (-1),IntegerVal 32767,IntegerVal (-13868),IntegerVal (-32768)]], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_s16(UINT64_C(0x00007fff23ef8000));
      arg2 = vcreate_s16(UINT64_C(0x8000c9d47fffffff));
      clear_neon_saturated();
      //  Expect: "result" = 8000c9d47fffffff00007fff23ef8000
      result = vcombine_s16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 0);
         exp = UINT64_C(0x00007fff23ef8000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 1);
         exp = UINT64_C(0x8000c9d47fffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1992() {

{
   {
      int32x2_t arg1;
      int32x2_t arg2;
      int32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"combine\", fnname = \"vcombine_s32\", rettype = \"int32x4_t\", argtypes = \"[int32x2_t,int32x2_t]\", vals = [VectorVal [IntegerVal 2147418112,IntegerVal 1609478096],VectorVal [IntegerVal (-1389494273),IntegerVal 32767]], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_s32(UINT64_C(0x5feeafd07fff0000));
      arg2 = vcreate_s32(UINT64_C(0x00007fffad2dffff));
      clear_neon_saturated();
      //  Expect: "result" = 00007fffad2dffff5feeafd07fff0000
      result = vcombine_s32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 0);
         exp = UINT64_C(0x5feeafd07fff0000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 1);
         exp = UINT64_C(0x00007fffad2dffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1993() {

{
   {
      int64x1_t arg1;
      int64x1_t arg2;
      int64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"combine\", fnname = \"vcombine_s64\", rettype = \"int64x2_t\", argtypes = \"[int64x1_t,int64x1_t]\", vals = [VectorVal [IntegerVal (-140733193420801)],VectorVal [IntegerVal (-281471327036171)]], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_s64(UINT64_C(0xffff8000ffff7fff));
      arg2 = vcreate_s64(UINT64_C(0xffff0000d9899cf5));
      clear_neon_saturated();
      //  Expect: "result" = ffff0000d9899cf5ffff8000ffff7fff
      result = vcombine_s64(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 0);
         exp = UINT64_C(0xffff8000ffff7fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 1);
         exp = UINT64_C(0xffff0000d9899cf5);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1994() {

{
   {
      float32x2_t arg1;
      float32x2_t arg2;
      float32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"combine\", fnname = \"vcombine_f32\", rettype = \"float32x4_t\", argtypes = \"[float32x2_t,float32x2_t]\", vals = [VectorVal [FloatVal 0.7348843812942505,FloatVal 0.7499196529388428],VectorVal [FloatVal 0.8740400671958923,FloatVal 0.9662034511566162]], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_f32(UINT64_C(0x3f3ffabc3f3c2162));
      arg2 = vcreate_f32(UINT64_C(0x3f77591c3f5fc117));
      clear_neon_saturated();
      //  Expect: "result" = 3f77591c3f5fc1173f3ffabc3f3c2162
      result = vcombine_f32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 0);
         exp = ((float32_t) 0.7348843812942505);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 1);
         exp = ((float32_t) 0.7499196529388428);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 2);
         exp = ((float32_t) 0.8740400671958923);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 2 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 3);
         exp = ((float32_t) 0.9662034511566162);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 3 ", exp, got);
            }
      }
   }
}
}
void dotests_1995() {

{
   {
      uint8x8_t arg1;
      uint8x8_t arg2;
      uint8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"combine\", fnname = \"vcombine_u8\", rettype = \"uint8x16_t\", argtypes = \"[uint8x8_t,uint8x8_t]\", vals = [VectorVal [IntegerVal 0,IntegerVal 128,IntegerVal 0,IntegerVal 255,IntegerVal 0,IntegerVal 255,IntegerVal 156,IntegerVal 0],VectorVal [IntegerVal 0,IntegerVal 128,IntegerVal 127,IntegerVal 127,IntegerVal 127,IntegerVal 127,IntegerVal 201,IntegerVal 127]], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_u8(UINT64_C(0x009cff00ff008000));
      arg2 = vcreate_u8(UINT64_C(0x7fc97f7f7f7f8000));
      clear_neon_saturated();
      //  Expect: "result" = 7fc97f7f7f7f8000009cff00ff008000
      result = vcombine_u8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 0);
         exp = UINT64_C(0x009cff00ff008000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 1);
         exp = UINT64_C(0x7fc97f7f7f7f8000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1996() {

{
   {
      uint16x4_t arg1;
      uint16x4_t arg2;
      uint16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"combine\", fnname = \"vcombine_u16\", rettype = \"uint16x8_t\", argtypes = \"[uint16x4_t,uint16x4_t]\", vals = [VectorVal [IntegerVal 0,IntegerVal 63295,IntegerVal 65535,IntegerVal 65272],VectorVal [IntegerVal 32767,IntegerVal 0,IntegerVal 0,IntegerVal 0]], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_u16(UINT64_C(0xfef8fffff73f0000));
      arg2 = vcreate_u16(UINT64_C(0x0000000000007fff));
      clear_neon_saturated();
      //  Expect: "result" = 0000000000007ffffef8fffff73f0000
      result = vcombine_u16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 0);
         exp = UINT64_C(0xfef8fffff73f0000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 1);
         exp = UINT64_C(0x0000000000007fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1997() {

{
   {
      uint32x2_t arg1;
      uint32x2_t arg2;
      uint32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"combine\", fnname = \"vcombine_u32\", rettype = \"uint32x4_t\", argtypes = \"[uint32x2_t,uint32x2_t]\", vals = [VectorVal [IntegerVal 0,IntegerVal 1575518207],VectorVal [IntegerVal 81231871,IntegerVal 65535]], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_u32(UINT64_C(0x5de87fff00000000));
      arg2 = vcreate_u32(UINT64_C(0x0000ffff04d77fff));
      clear_neon_saturated();
      //  Expect: "result" = 0000ffff04d77fff5de87fff00000000
      result = vcombine_u32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 0);
         exp = UINT64_C(0x5de87fff00000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 1);
         exp = UINT64_C(0x0000ffff04d77fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1998() {

{
   {
      uint64x1_t arg1;
      uint64x1_t arg2;
      uint64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"combine\", fnname = \"vcombine_u64\", rettype = \"uint64x2_t\", argtypes = \"[uint64x1_t,uint64x1_t]\", vals = [VectorVal [IntegerVal 9223372034707292160],VectorVal [IntegerVal 18446603337561276416]], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_u64(UINT64_C(0x7fffffff80000000));
      arg2 = vcreate_u64(UINT64_C(0xffff80004fe00000));
      clear_neon_saturated();
      //  Expect: "result" = ffff80004fe000007fffffff80000000
      result = vcombine_u64(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 0);
         exp = UINT64_C(0x7fffffff80000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 1);
         exp = UINT64_C(0xffff80004fe00000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_1999() {

{
   {
      poly8x8_t arg1;
      poly8x8_t arg2;
      poly8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"combine\", fnname = \"vcombine_p8\", rettype = \"poly8x16_t\", argtypes = \"[poly8x8_t,poly8x8_t]\", vals = [VectorVal [PolyVal [1,1,1,0,0,0,1,1],PolyVal [0,1,1,0,1,1,1,0],PolyVal [1,0,1,1,0,1,1,0],PolyVal [0,1,0,1,1,0,0,0],PolyVal [0,1,1,1,1,0,1,1],PolyVal [1,0,0,0,1,1,0,0],PolyVal [0,0,0,1,0,1,0,1],PolyVal [1,1,0,0,1,0,1,1]],VectorVal [PolyVal [1,1,1,0,1,0,0,1],PolyVal [0,1,0,1,0,0,0,0],PolyVal [1,0,0,0,0,0,1,1],PolyVal [1,1,1,1,1,0,0,0],PolyVal [1,1,1,0,1,1,1,1],PolyVal [0,0,1,0,1,1,0,1],PolyVal [0,1,0,1,1,1,1,1],PolyVal [0,0,0,1,0,1,1,0]]], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_p8(UINT64_C(0xd3a831de1a6d76c7));
      arg2 = vcreate_p8(UINT64_C(0x68fab4f71fc10a97));
      clear_neon_saturated();
      //  Expect: "result" = 68fab4f71fc10a97d3a831de1a6d76c7
      result = vcombine_p8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p8(result), 0);
         exp = UINT64_C(0xd3a831de1a6d76c7);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p8(result), 1);
         exp = UINT64_C(0x68fab4f71fc10a97);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2000() {

{
   {
      poly16x4_t arg1;
      poly16x4_t arg2;
      poly16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"combine\", fnname = \"vcombine_p16\", rettype = \"poly16x8_t\", argtypes = \"[poly16x4_t,poly16x4_t]\", vals = [VectorVal [PolyVal [0,0,0,1,1,1,0,1,0,0,1,1,1,0,1,1],PolyVal [0,1,0,0,1,0,1,0,0,0,0,1,0,0,0,1],PolyVal [0,0,0,1,1,1,1,0,0,1,1,0,1,0,1,0],PolyVal [1,0,1,0,1,1,0,0,0,1,0,0,1,1,0,1]],VectorVal [PolyVal [1,1,0,1,0,0,0,1,1,0,1,0,1,1,0,0],PolyVal [1,1,0,0,1,1,0,1,1,1,1,1,1,0,1,1],PolyVal [1,1,0,1,0,1,0,1,0,1,1,1,1,0,1,1],PolyVal [0,0,1,1,0,1,0,1,0,0,1,0,1,1,0,1]]], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_p16(UINT64_C(0xb23556788852dcb8));
      arg2 = vcreate_p16(UINT64_C(0xb4acdeabdfb3358b));
      clear_neon_saturated();
      //  Expect: "result" = b4acdeabdfb3358bb23556788852dcb8
      result = vcombine_p16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p16(result), 0);
         exp = UINT64_C(0xb23556788852dcb8);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p16(result), 1);
         exp = UINT64_C(0xb4acdeabdfb3358b);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2001() {
#if __ARM_NEON_FP16_INTRINSICS

{
   {
      float16x4_t arg1;
      float16x4_t arg2;
      float16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"combine\", fnname = \"vcombine_f16\", rettype = \"float16x8_t\", argtypes = \"[float16x4_t,float16x4_t]\", vals = [VectorVal [FloatVal 5.853165283435738,FloatVal 3.575937636501065,FloatVal (-1.2201476409657293),FloatVal 9.22405602848928],VectorVal [FloatVal (-1.1336361387785914),FloatVal (-1.037966030417639),FloatVal 7.315904162853496,FloatVal (-4.936373816879247)]], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_f16(UINT64_C(0x489cbce1432645da));
      arg2 = vcreate_f16(UINT64_C(0xc4ef4750bc26bc88));
      clear_neon_saturated();
      //  Expect: "result" = c4ef4750bc26bc88489cbce1432645da
      result = vcombine_f16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result, 0);
         exp = 5.853165283435738;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result, 1);
         exp = 3.575937636501065;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result, 2);
         exp = -1.2201476409657293;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 2 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result, 3);
         exp = 9.22405602848928;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 3 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result, 4);
         exp = -1.1336361387785914;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 4 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result, 5);
         exp = -1.037966030417639;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 5 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result, 6);
         exp = 7.315904162853496;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 6 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result, 7);
         exp = -4.936373816879247;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 7 ", exp, got);
            }
      }
   }
}
#endif
}
void dotests_2002() {

{
   {
      float64x1_t arg1;
      float64x1_t arg2;
      float64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"combine\", fnname = \"vcombine_f64\", rettype = \"float64x2_t\", argtypes = \"[float64x1_t,float64x1_t]\", vals = [VectorVal [FloatVal 0.3307265905659239],VectorVal [FloatVal 0.5460889256803259]], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_f64(UINT64_C(0x3fd52a9fdc997c86));
      arg2 = vcreate_f64(UINT64_C(0x3fe1798f7b90271c));
      clear_neon_saturated();
      //  Expect: "result" = 3fe1798f7b90271c3fd52a9fdc997c86
      result = vcombine_f64(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float64_t got;
         float64_t exp;
         got = vgetq_lane_f64(result, 0);
         exp = 0.3307265905659239;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float64_t got;
         float64_t exp;
         got = vgetq_lane_f64(result, 1);
         exp = 0.5460889256803259;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
   }
}
}
void dotests_2003() {

{
   {
      poly64x1_t arg1;
      poly64x1_t arg2;
      poly64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"combine\", fnname = \"vcombine_p64\", rettype = \"poly64x2_t\", argtypes = \"[poly64x1_t,poly64x1_t]\", vals = [VectorVal [PolyVal [1,1,1,0,1,1,1,0,1,0,1,1,0,1,0,1,1,1,1,0,1,0,0,1,0,1,1,1,1,1,1,0,1,1,1,0,1,0,0,0,1,0,1,1,0,1,0,1,1,1,1,1,1,1,0,0,0,1,1,1,1,1,0,0]],VectorVal [PolyVal [1,0,1,1,0,0,0,0,1,0,0,0,1,1,0,1,0,0,0,1,0,0,0,0,1,0,0,1,1,0,1,1,0,1,0,0,0,1,1,0,1,0,0,0,0,0,1,1,0,0,0,0,0,1,1,1,0,0,1,1,1,1,1,1]]], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_p64(UINT64_C(0x3e3fad177e97ad77));
      arg2 = vcreate_p64(UINT64_C(0xfce0c162d908b10d));
      clear_neon_saturated();
      //  Expect: "result" = fce0c162d908b10d3e3fad177e97ad77
      result = vcombine_p64(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p64(result), 0);
         exp = UINT64_C(0x3e3fad177e97ad77);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p64(result), 1);
         exp = UINT64_C(0xfce0c162d908b10d);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2004() {

{
   {
      int8x16_t arg1;
      int8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"get_highvector\", fnname = \"vget_high_s8\", rettype = \"int8x8_t\", argtypes = \"[int8x16_t]\", vals = [VectorVal [IntegerVal 127,IntegerVal (-1),IntegerVal (-1),IntegerVal 49,IntegerVal 38,IntegerVal (-1),IntegerVal (-128),IntegerVal (-1),IntegerVal (-128),IntegerVal (-128),IntegerVal (-128),IntegerVal 127,IntegerVal 127,IntegerVal 0,IntegerVal (-128),IntegerVal (-65)]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcombine_s8(vcreate_s8(UINT64_C(0xff80ff2631ffff7f)),
                         vcreate_s8(UINT64_C(0xbf80007f7f808080)));
      clear_neon_saturated();
      //  Expect: "result" = bf80007f7f808080
      result = vget_high_s8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s8(result), 0);
      exp = UINT64_C(0xbf80007f7f808080);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2005() {

{
   {
      int16x8_t arg1;
      int16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"get_highvector\", fnname = \"vget_high_s16\", rettype = \"int16x4_t\", argtypes = \"[int16x8_t]\", vals = [VectorVal [IntegerVal (-19941),IntegerVal (-1),IntegerVal 32767,IntegerVal 20503,IntegerVal 32767,IntegerVal 32767,IntegerVal (-32768),IntegerVal (-1)]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcombine_s16(vcreate_s16(UINT64_C(0x50177fffffffb21b)),
                          vcreate_s16(UINT64_C(0xffff80007fff7fff)));
      clear_neon_saturated();
      //  Expect: "result" = ffff80007fff7fff
      result = vget_high_s16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s16(result), 0);
      exp = UINT64_C(0xffff80007fff7fff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2006() {

{
   {
      int32x4_t arg1;
      int32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"get_highvector\", fnname = \"vget_high_s32\", rettype = \"int32x2_t\", argtypes = \"[int32x4_t]\", vals = [VectorVal [IntegerVal (-32768),IntegerVal 65535,IntegerVal (-2147450881),IntegerVal (-44782)]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcombine_s32(vcreate_s32(UINT64_C(0x0000ffffffff8000)),
                          vcreate_s32(UINT64_C(0xffff511280007fff)));
      clear_neon_saturated();
      //  Expect: "result" = ffff511280007fff
      result = vget_high_s32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s32(result), 0);
      exp = UINT64_C(0xffff511280007fff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2007() {

{
   {
      int64x2_t arg1;
      int64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"get_highvector\", fnname = \"vget_high_s64\", rettype = \"int64x1_t\", argtypes = \"[int64x2_t]\", vals = [VectorVal [IntegerVal (-944348546864218112),IntegerVal (-9223372036854743041)]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcombine_s64(vcreate_s64(UINT64_C(0xf2e5000000008000)),
                          vcreate_s64(UINT64_C(0x8000000000007fff)));
      clear_neon_saturated();
      //  Expect: "result" = 8000000000007fff
      result = vget_high_s64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s64(result), 0);
      exp = UINT64_C(0x8000000000007fff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2008() {

{
   {
      float32x4_t arg1;
      float32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"get_highvector\", fnname = \"vget_high_f32\", rettype = \"float32x2_t\", argtypes = \"[float32x4_t]\", vals = [VectorVal [FloatVal 0.6589087247848511,FloatVal 0.4844818115234375,FloatVal 0.7862609028816223,FloatVal 0.16028869152069092]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_f32(vcreate_f32(UINT64_C(0x3ef80e003f28ae3e)),
                          vcreate_f32(UINT64_C(0x3e2422b83f494865)));
      clear_neon_saturated();
      //  Expect: "result" = 3e2422b83f494865
      result = vget_high_f32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result, 0);
         exp = ((float32_t) 0.7862609028816223);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result, 1);
         exp = ((float32_t) 0.16028869152069092);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
   }
}
}
void dotests_2009() {

{
   {
      uint8x16_t arg1;
      uint8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"get_highvector\", fnname = \"vget_high_u8\", rettype = \"uint8x8_t\", argtypes = \"[uint8x16_t]\", vals = [VectorVal [IntegerVal 128,IntegerVal 0,IntegerVal 0,IntegerVal 128,IntegerVal 255,IntegerVal 255,IntegerVal 0,IntegerVal 0,IntegerVal 242,IntegerVal 0,IntegerVal 0,IntegerVal 0,IntegerVal 255,IntegerVal 0,IntegerVal 0,IntegerVal 128]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcombine_u8(vcreate_u8(UINT64_C(0x0000ffff80000080)),
                         vcreate_u8(UINT64_C(0x800000ff000000f2)));
      clear_neon_saturated();
      //  Expect: "result" = 800000ff000000f2
      result = vget_high_u8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u8(result), 0);
      exp = UINT64_C(0x800000ff000000f2);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2010() {

{
   {
      uint16x8_t arg1;
      uint16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"get_highvector\", fnname = \"vget_high_u16\", rettype = \"uint16x4_t\", argtypes = \"[uint16x8_t]\", vals = [VectorVal [IntegerVal 47793,IntegerVal 32767,IntegerVal 32768,IntegerVal 32767,IntegerVal 0,IntegerVal 32768,IntegerVal 65535,IntegerVal 32768]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcombine_u16(vcreate_u16(UINT64_C(0x7fff80007fffbab1)),
                          vcreate_u16(UINT64_C(0x8000ffff80000000)));
      clear_neon_saturated();
      //  Expect: "result" = 8000ffff80000000
      result = vget_high_u16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u16(result), 0);
      exp = UINT64_C(0x8000ffff80000000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2011() {

{
   {
      uint32x4_t arg1;
      uint32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"get_highvector\", fnname = \"vget_high_u32\", rettype = \"uint32x2_t\", argtypes = \"[uint32x4_t]\", vals = [VectorVal [IntegerVal 2147483648,IntegerVal 4060436005,IntegerVal 4294934528,IntegerVal 65535]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcombine_u32(vcreate_u32(UINT64_C(0xf205562580000000)),
                          vcreate_u32(UINT64_C(0x0000ffffffff8000)));
      clear_neon_saturated();
      //  Expect: "result" = 0000ffffffff8000
      result = vget_high_u32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u32(result), 0);
      exp = UINT64_C(0x0000ffffffff8000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2012() {

{
   {
      uint64x2_t arg1;
      uint64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"get_highvector\", fnname = \"vget_high_u64\", rettype = \"uint64x1_t\", argtypes = \"[uint64x2_t]\", vals = [VectorVal [IntegerVal 9223372032559808512,IntegerVal 9223231295071485952]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcombine_u64(vcreate_u64(UINT64_C(0x7fffffff00000000)),
                          vcreate_u64(UINT64_C(0x7fff7fff00008000)));
      clear_neon_saturated();
      //  Expect: "result" = 7fff7fff00008000
      result = vget_high_u64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(result, 0);
      exp = UINT64_C(0x7fff7fff00008000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2013() {

{
   {
      poly8x16_t arg1;
      poly8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"get_highvector\", fnname = \"vget_high_p8\", rettype = \"poly8x8_t\", argtypes = \"[poly8x16_t]\", vals = [VectorVal [PolyVal [1,1,1,0,0,1,0,1],PolyVal [1,1,0,0,1,0,1,1],PolyVal [1,0,1,0,0,1,1,1],PolyVal [1,1,1,1,0,1,1,1],PolyVal [0,1,0,1,0,0,1,0],PolyVal [0,0,1,0,1,1,0,0],PolyVal [1,0,0,1,1,0,0,1],PolyVal [1,1,0,0,1,1,1,0],PolyVal [1,1,1,0,1,0,0,1],PolyVal [0,0,0,1,0,1,0,1],PolyVal [1,0,0,0,1,0,1,1],PolyVal [0,0,1,1,1,0,1,0],PolyVal [1,1,0,0,1,0,0,0],PolyVal [0,0,1,0,1,1,0,1],PolyVal [0,0,0,0,1,0,0,0],PolyVal [0,0,0,0,0,0,1,0]]], start_saturated = True}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcombine_p8(vcreate_p8(UINT64_C(0x7399344aefe5d3a7)),
                         vcreate_p8(UINT64_C(0x4010b4135cd1a897)));
      set_neon_saturated();
      //  Expect: "result" = 4010b4135cd1a897
      result = vget_high_p8(arg1);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_p8(result), 0);
      exp = UINT64_C(0x4010b4135cd1a897);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2014() {

{
   {
      poly16x8_t arg1;
      poly16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"get_highvector\", fnname = \"vget_high_p16\", rettype = \"poly16x4_t\", argtypes = \"[poly16x8_t]\", vals = [VectorVal [PolyVal [1,1,1,0,1,0,0,1,0,1,0,0,1,1,1,1],PolyVal [1,1,1,0,0,1,0,0,1,1,0,0,1,1,0,1],PolyVal [0,0,1,0,1,0,0,0,0,0,0,1,1,0,1,1],PolyVal [1,0,1,1,1,1,1,1,0,1,0,1,0,1,1,1],PolyVal [0,0,0,1,1,1,0,0,0,0,0,0,0,1,0,0],PolyVal [0,1,1,0,1,1,1,0,0,0,1,1,0,0,0,0],PolyVal [0,1,1,0,1,1,1,1,0,0,0,0,0,0,0,1],PolyVal [0,0,0,0,1,0,1,1,1,1,0,1,0,0,1,0]]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcombine_p16(vcreate_p16(UINT64_C(0xeafdd814b327f297)),
                          vcreate_p16(UINT64_C(0x4bd080f60c762038)));
      clear_neon_saturated();
      //  Expect: "result" = 4bd080f60c762038
      result = vget_high_p16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_p16(result), 0);
      exp = UINT64_C(0x4bd080f60c762038);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2015() {
#if __ARM_NEON_FP16_INTRINSICS

{
   {
      float16x8_t arg1;
      float16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"get_highvector\", fnname = \"vget_high_f16\", rettype = \"float16x4_t\", argtypes = \"[float16x8_t]\", vals = [VectorVal [FloatVal 5.410963343581635,FloatVal 1.5816545915583333,FloatVal (-5.4882164416232726e-2),FloatVal 7.012308884353743,FloatVal 3.052315302266832,FloatVal 1.7653755116723104,FloatVal 9.449380477482816,FloatVal 3.5754306337225152]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_f16(vcreate_f16(UINT64_C(0x4703ab063e534569)),
                          vcreate_f16(UINT64_C(0x432648b93f0f421a)));
      clear_neon_saturated();
      //  Expect: "result" = 432648b93f0f421a
      result = vget_high_f16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         __fp16 got;
         __fp16 exp;
         got = vget_lane_f16(result, 0);
         exp = 3.052315302266832;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vget_lane_f16(result, 1);
         exp = 1.7653755116723104;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vget_lane_f16(result, 2);
         exp = 9.449380477482816;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 2 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vget_lane_f16(result, 3);
         exp = 3.5754306337225152;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 3 ", exp, got);
            }
      }
   }
}
#endif
}
void dotests_2016() {

{
   {
      int8x16_t arg1;
      int8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"get_lowvector\", fnname = \"vget_low_s8\", rettype = \"int8x8_t\", argtypes = \"[int8x16_t]\", vals = [VectorVal [IntegerVal 127,IntegerVal 127,IntegerVal (-128),IntegerVal (-1),IntegerVal 127,IntegerVal 14,IntegerVal (-33),IntegerVal (-128),IntegerVal (-1),IntegerVal (-128),IntegerVal 127,IntegerVal (-1),IntegerVal (-128),IntegerVal (-128),IntegerVal 0,IntegerVal 127]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcombine_s8(vcreate_s8(UINT64_C(0x80df0e7fff807f7f)),
                         vcreate_s8(UINT64_C(0x7f008080ff7f80ff)));
      clear_neon_saturated();
      //  Expect: "result" = 80df0e7fff807f7f
      result = vget_low_s8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s8(result), 0);
      exp = UINT64_C(0x80df0e7fff807f7f);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2017() {

{
   {
      int16x8_t arg1;
      int16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"get_lowvector\", fnname = \"vget_low_s16\", rettype = \"int16x4_t\", argtypes = \"[int16x8_t]\", vals = [VectorVal [IntegerVal (-14848),IntegerVal 0,IntegerVal 32767,IntegerVal 14423,IntegerVal 0,IntegerVal 32767,IntegerVal (-32768),IntegerVal (-32768)]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcombine_s16(vcreate_s16(UINT64_C(0x38577fff0000c600)),
                          vcreate_s16(UINT64_C(0x800080007fff0000)));
      clear_neon_saturated();
      //  Expect: "result" = 38577fff0000c600
      result = vget_low_s16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s16(result), 0);
      exp = UINT64_C(0x38577fff0000c600);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2018() {

{
   {
      int32x4_t arg1;
      int32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"get_lowvector\", fnname = \"vget_low_s32\", rettype = \"int32x2_t\", argtypes = \"[int32x4_t]\", vals = [VectorVal [IntegerVal (-1),IntegerVal (-32768),IntegerVal (-971505665),IntegerVal 0]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcombine_s32(vcreate_s32(UINT64_C(0xffff8000ffffffff)),
                          vcreate_s32(UINT64_C(0x00000000c617ffff)));
      clear_neon_saturated();
      //  Expect: "result" = ffff8000ffffffff
      result = vget_low_s32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s32(result), 0);
      exp = UINT64_C(0xffff8000ffffffff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2019() {

{
   {
      int64x2_t arg1;
      int64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"get_lowvector\", fnname = \"vget_low_s64\", rettype = \"int64x1_t\", argtypes = \"[int64x2_t]\", vals = [VectorVal [IntegerVal (-281474976677888),IntegerVal 9223262068031389695]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcombine_s64(vcreate_s64(UINT64_C(0xffff000000008000)),
                          vcreate_s64(UINT64_C(0x7fff9bfbe3587fff)));
      clear_neon_saturated();
      //  Expect: "result" = ffff000000008000
      result = vget_low_s64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s64(result), 0);
      exp = UINT64_C(0xffff000000008000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2020() {

{
   {
      float32x4_t arg1;
      float32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"get_lowvector\", fnname = \"vget_low_f32\", rettype = \"float32x2_t\", argtypes = \"[float32x4_t]\", vals = [VectorVal [FloatVal 0.40148186683654785,FloatVal 0.9319316148757935,FloatVal 0.21375954151153564,FloatVal 0.989134669303894]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_f32(vcreate_f32(UINT64_C(0x3f6e93123ecd8f08)),
                          vcreate_f32(UINT64_C(0x3f7d37ee3e5ae3c8)));
      clear_neon_saturated();
      //  Expect: "result" = 3f6e93123ecd8f08
      result = vget_low_f32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result, 0);
         exp = ((float32_t) 0.40148186683654785);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result, 1);
         exp = ((float32_t) 0.9319316148757935);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
   }
}
}
void dotests_2021() {

{
   {
      uint8x16_t arg1;
      uint8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"get_lowvector\", fnname = \"vget_low_u8\", rettype = \"uint8x8_t\", argtypes = \"[uint8x16_t]\", vals = [VectorVal [IntegerVal 0,IntegerVal 0,IntegerVal 127,IntegerVal 0,IntegerVal 128,IntegerVal 128,IntegerVal 255,IntegerVal 127,IntegerVal 127,IntegerVal 0,IntegerVal 128,IntegerVal 127,IntegerVal 128,IntegerVal 127,IntegerVal 0,IntegerVal 255]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcombine_u8(vcreate_u8(UINT64_C(0x7fff8080007f0000)),
                         vcreate_u8(UINT64_C(0xff007f807f80007f)));
      clear_neon_saturated();
      //  Expect: "result" = 7fff8080007f0000
      result = vget_low_u8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u8(result), 0);
      exp = UINT64_C(0x7fff8080007f0000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2022() {

{
   {
      uint16x8_t arg1;
      uint16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"get_lowvector\", fnname = \"vget_low_u16\", rettype = \"uint16x4_t\", argtypes = \"[uint16x8_t]\", vals = [VectorVal [IntegerVal 65535,IntegerVal 32767,IntegerVal 32768,IntegerVal 32768,IntegerVal 12979,IntegerVal 32768,IntegerVal 65535,IntegerVal 0]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcombine_u16(vcreate_u16(UINT64_C(0x800080007fffffff)),
                          vcreate_u16(UINT64_C(0x0000ffff800032b3)));
      clear_neon_saturated();
      //  Expect: "result" = 800080007fffffff
      result = vget_low_u16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u16(result), 0);
      exp = UINT64_C(0x800080007fffffff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2023() {

{
   {
      uint32x4_t arg1;
      uint32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"get_lowvector\", fnname = \"vget_low_u32\", rettype = \"uint32x2_t\", argtypes = \"[uint32x4_t]\", vals = [VectorVal [IntegerVal 0,IntegerVal 32767,IntegerVal 32768,IntegerVal 4294901760]], start_saturated = True}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcombine_u32(vcreate_u32(UINT64_C(0x00007fff00000000)),
                          vcreate_u32(UINT64_C(0xffff000000008000)));
      set_neon_saturated();
      //  Expect: "result" = 00007fff00000000
      result = vget_low_u32(arg1);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u32(result), 0);
      exp = UINT64_C(0x00007fff00000000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2024() {

{
   {
      uint64x2_t arg1;
      uint64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"get_lowvector\", fnname = \"vget_low_u64\", rettype = \"uint64x1_t\", argtypes = \"[uint64x2_t]\", vals = [VectorVal [IntegerVal 9166232620877479935,IntegerVal 9223231301513936895]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcombine_u64(vcreate_u64(UINT64_C(0x7f350000ffffffff)),
                          vcreate_u64(UINT64_C(0x7fff800080007fff)));
      clear_neon_saturated();
      //  Expect: "result" = 7f350000ffffffff
      result = vget_low_u64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(result, 0);
      exp = UINT64_C(0x7f350000ffffffff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2025() {

{
   {
      poly8x16_t arg1;
      poly8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"get_lowvector\", fnname = \"vget_low_p8\", rettype = \"poly8x8_t\", argtypes = \"[poly8x16_t]\", vals = [VectorVal [PolyVal [1,1,1,0,0,0,1,0],PolyVal [0,1,0,1,0,1,0,1],PolyVal [1,0,0,0,0,0,0,0],PolyVal [1,0,1,0,0,0,0,0],PolyVal [0,0,1,0,0,1,1,1],PolyVal [0,0,0,1,1,0,0,1],PolyVal [1,0,0,0,1,0,0,0],PolyVal [1,0,0,0,1,0,1,1],PolyVal [1,1,1,1,0,1,0,1],PolyVal [1,1,1,0,0,0,0,0],PolyVal [0,1,1,0,1,1,1,1],PolyVal [0,0,0,1,1,0,1,0],PolyVal [0,0,1,0,0,0,0,0],PolyVal [1,1,0,0,0,0,0,1],PolyVal [0,1,0,1,1,0,1,0],PolyVal [0,1,1,0,0,0,1,1]]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcombine_p8(vcreate_p8(UINT64_C(0xd11198e40501aa47)),
                         vcreate_p8(UINT64_C(0xc65a830458f607af)));
      clear_neon_saturated();
      //  Expect: "result" = d11198e40501aa47
      result = vget_low_p8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_p8(result), 0);
      exp = UINT64_C(0xd11198e40501aa47);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2026() {

{
   {
      poly16x8_t arg1;
      poly16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"get_lowvector\", fnname = \"vget_low_p16\", rettype = \"poly16x4_t\", argtypes = \"[poly16x8_t]\", vals = [VectorVal [PolyVal [1,1,1,1,0,1,1,0,0,0,0,0,0,1,0,1],PolyVal [0,1,0,1,1,1,0,1,1,0,0,0,1,1,1,0],PolyVal [0,0,0,1,0,1,0,1,1,1,1,1,0,0,0,0],PolyVal [1,1,1,0,1,1,1,1,1,1,0,0,0,1,1,1],PolyVal [1,1,1,0,0,0,0,1,1,0,1,1,0,1,1,1],PolyVal [0,1,1,0,0,1,1,1,0,0,1,1,1,1,1,1],PolyVal [0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0],PolyVal [0,1,0,0,1,0,1,1,1,0,1,0,1,0,1,1]]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcombine_p16(vcreate_p16(UINT64_C(0xe3f70fa871baa06f)),
                          vcreate_p16(UINT64_C(0xd5d20210fce6ed87)));
      clear_neon_saturated();
      //  Expect: "result" = e3f70fa871baa06f
      result = vget_low_p16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_p16(result), 0);
      exp = UINT64_C(0xe3f70fa871baa06f);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2027() {
#if __ARM_NEON_FP16_INTRINSICS

{
   {
      float16x8_t arg1;
      float16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"get_lowvector\", fnname = \"vget_low_f16\", rettype = \"float16x4_t\", argtypes = \"[float16x8_t]\", vals = [VectorVal [FloatVal (-9.258822415974823),FloatVal 1.1998697385328416,FloatVal (-7.706277666602288),FloatVal 2.2259639990205393,FloatVal (-8.438411384010108),FloatVal 4.676771971189931,FloatVal 6.16016060776251,FloatVal 5.918113587830831]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_f16(vcreate_f16(UINT64_C(0x4073c7b43cccc8a1)),
                          vcreate_f16(UINT64_C(0x45eb462944adc838)));
      clear_neon_saturated();
      //  Expect: "result" = 4073c7b43cccc8a1
      result = vget_low_f16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         __fp16 got;
         __fp16 exp;
         got = vget_lane_f16(result, 0);
         exp = -9.258822415974823;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vget_lane_f16(result, 1);
         exp = 1.1998697385328416;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vget_lane_f16(result, 2);
         exp = -7.706277666602288;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 2 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vget_lane_f16(result, 3);
         exp = 2.2259639990205393;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 3 ", exp, got);
            }
      }
   }
}
#endif
}
void dotests_2028() {

{
   {
      float64x2_t arg1;
      float64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"get_highvector\", fnname = \"vget_high_f64\", rettype = \"float64x1_t\", argtypes = \"[float64x2_t]\", vals = [VectorVal [FloatVal 0.10266409790479092,FloatVal 0.49043096162916056]], start_saturated = False}";
      int reported = 0;
      float64_t got;
      float64_t exp;
      arg1 = vcombine_f64(vcreate_f64(UINT64_C(0x3fba4831bef97388)),
                          vcreate_f64(UINT64_C(0x3fdf63388b492826)));
      clear_neon_saturated();
      //  Expect: "result" = 3fdf63388b492826
      result = vget_high_f64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_f64(result, 0);
      exp = 0.49043096162916056;
      if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
         }
   }
}
}
void dotests_2029() {

{
   {
      poly64x2_t arg1;
      poly64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"get_highvector\", fnname = \"vget_high_p64\", rettype = \"poly64x1_t\", argtypes = \"[poly64x2_t]\", vals = [VectorVal [PolyVal [0,0,1,0,0,1,0,1,0,1,1,1,1,0,0,0,0,1,1,1,1,0,0,1,0,1,0,1,0,1,0,0,0,1,0,0,1,1,1,1,1,0,0,0,1,1,1,0,1,1,0,0,0,0,1,1,0,1,1,1,0,1,1,1],PolyVal [1,1,0,1,0,0,0,1,1,1,1,1,0,0,0,0,0,1,0,0,0,1,1,0,1,1,1,1,0,0,1,0,1,1,0,1,0,0,1,1,1,1,0,0,1,0,1,1,1,0,1,0,0,0,0,0,0,1,1,1,0,1,0,0]]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcombine_p64(vcreate_p64(UINT64_C(0xeec371f22a9e1ea4)),
                          vcreate_p64(UINT64_C(0x2e05d3cb4f620f8b)));
      clear_neon_saturated();
      //  Expect: "result" = 2e05d3cb4f620f8b
      result = vget_high_p64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_p64(result), 0);
      exp = UINT64_C(0x2e05d3cb4f620f8b);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2030() {

{
   {
      float64x2_t arg1;
      float64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"get_lowvector\", fnname = \"vget_low_f64\", rettype = \"float64x1_t\", argtypes = \"[float64x2_t]\", vals = [VectorVal [FloatVal 0.881016109023108,FloatVal 0.6990205794167094]], start_saturated = False}";
      int reported = 0;
      float64_t got;
      float64_t exp;
      arg1 = vcombine_f64(vcreate_f64(UINT64_C(0x3fec3148b1f01c03)),
                          vcreate_f64(UINT64_C(0x3fe65e6067fa6c71)));
      clear_neon_saturated();
      //  Expect: "result" = 3fec3148b1f01c03
      result = vget_low_f64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_f64(result, 0);
      exp = 0.881016109023108;
      if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
         }
   }
}
}
void dotests_2031() {

{
   {
      poly64x2_t arg1;
      poly64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"get_lowvector\", fnname = \"vget_low_p64\", rettype = \"poly64x1_t\", argtypes = \"[poly64x2_t]\", vals = [VectorVal [PolyVal [1,0,0,0,0,0,1,1,1,0,0,1,1,0,0,0,0,0,1,0,1,1,0,0,1,0,0,0,1,0,0,0,1,0,1,1,1,1,1,0,1,1,1,0,0,0,1,0,0,1,0,1,1,0,0,0,1,0,1,1,0,0,1,1],PolyVal [0,1,0,0,0,0,1,0,1,0,1,1,0,0,1,1,1,0,1,1,1,1,1,1,1,1,0,1,0,1,0,1,1,0,1,1,1,0,0,0,1,1,1,0,1,0,0,1,0,0,0,1,1,0,1,0,0,1,0,1,0,1,1,1]]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcombine_p64(vcreate_p64(UINT64_C(0xcd1a477d113419c1)),
                          vcreate_p64(UINT64_C(0xea58971dabfdcd42)));
      clear_neon_saturated();
      //  Expect: "result" = cd1a477d113419c1
      result = vget_low_p64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_p64(result), 0);
      exp = UINT64_C(0xcd1a477d113419c1);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2032() {

{
   {
      float32x2_t arg1;
      int32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"cvtn\", fnname = \"vcvtn_s32_f32\", rettype = \"int32x2_t\", argtypes = \"[float32x2_t]\", vals = [VectorVal [FloatVal 0.831185519695282,FloatVal 0.31092917919158936]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_f32(UINT64_C(0x3e9f321c3f54c893));
      clear_neon_saturated();
      //  Expect: "result" = 0000000000000001
      result = vcvtn_s32_f32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s32(result), 0);
      exp = UINT64_C(0x0000000000000001);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2033() {

{
   {
      float32x2_t arg1;
      int32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"cvtp\", fnname = \"vcvtp_s32_f32\", rettype = \"int32x2_t\", argtypes = \"[float32x2_t]\", vals = [VectorVal [FloatVal 0.4101267457008362,FloatVal 0.568779468536377]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_f32(UINT64_C(0x3f119b883ed1fc22));
      clear_neon_saturated();
      //  Expect: "result" = 0000000100000001
      result = vcvtp_s32_f32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s32(result), 0);
      exp = UINT64_C(0x0000000100000001);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2034() {

{
   {
      float32x2_t arg1;
      int32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"cvtm\", fnname = \"vcvtm_s32_f32\", rettype = \"int32x2_t\", argtypes = \"[float32x2_t]\", vals = [VectorVal [FloatVal 0.2744483947753906,FloatVal 0.3475133180618286]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_f32(UINT64_C(0x3eb1ed443e8c8480));
      clear_neon_saturated();
      //  Expect: "result" = 0000000000000000
      result = vcvtm_s32_f32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s32(result), 0);
      exp = 0;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2035() {

{
   {
      float32x2_t arg1;
      int32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"cvt\", fnname = \"vcvt_s32_f32\", rettype = \"int32x2_t\", argtypes = \"[float32x2_t]\", vals = [VectorVal [FloatVal 0.9635239839553833,FloatVal 0.601014256477356]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_f32(UINT64_C(0x3f19dc123f76a982));
      clear_neon_saturated();
      //  Expect: "result" = 0000000000000000
      result = vcvt_s32_f32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s32(result), 0);
      exp = 0;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2036() {

{
   {
      float32x2_t arg1;
      int32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"cvta\", fnname = \"vcvta_s32_f32\", rettype = \"int32x2_t\", argtypes = \"[float32x2_t]\", vals = [VectorVal [FloatVal 0.6827499866485596,FloatVal 0.9395259618759155]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_f32(UINT64_C(0x3f7084c63f2ec8b4));
      clear_neon_saturated();
      //  Expect: "result" = 0000000100000001
      result = vcvta_s32_f32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s32(result), 0);
      exp = UINT64_C(0x0000000100000001);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2037() {

{
   {
      float32x2_t arg1;
      uint32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"cvtn\", fnname = \"vcvtn_u32_f32\", rettype = \"uint32x2_t\", argtypes = \"[float32x2_t]\", vals = [VectorVal [FloatVal 0.34066736698150635,FloatVal 0.7057633399963379]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_f32(UINT64_C(0x3f34ace83eae6bf4));
      clear_neon_saturated();
      //  Expect: "result" = 0000000100000000
      result = vcvtn_u32_f32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u32(result), 0);
      exp = UINT64_C(0x0000000100000000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2038() {

{
   {
      float32x2_t arg1;
      uint32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"cvtp\", fnname = \"vcvtp_u32_f32\", rettype = \"uint32x2_t\", argtypes = \"[float32x2_t]\", vals = [VectorVal [FloatVal 0.5980697274208069,FloatVal 0.5058209300041199]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_f32(UINT64_C(0x3f017d7b3f191b19));
      clear_neon_saturated();
      //  Expect: "result" = 0000000100000001
      result = vcvtp_u32_f32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u32(result), 0);
      exp = UINT64_C(0x0000000100000001);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2039() {

{
   {
      float32x2_t arg1;
      uint32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"cvtm\", fnname = \"vcvtm_u32_f32\", rettype = \"uint32x2_t\", argtypes = \"[float32x2_t]\", vals = [VectorVal [FloatVal 0.304166316986084,FloatVal 4.378974437713623e-3]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_f32(UINT64_C(0x3b8f7d803e9bbbb0));
      clear_neon_saturated();
      //  Expect: "result" = 0000000000000000
      result = vcvtm_u32_f32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u32(result), 0);
      exp = 0;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2040() {

{
   {
      float32x2_t arg1;
      uint32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"cvt\", fnname = \"vcvt_u32_f32\", rettype = \"uint32x2_t\", argtypes = \"[float32x2_t]\", vals = [VectorVal [FloatVal 0.9205526113510132,FloatVal 0.20177459716796875]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_f32(UINT64_C(0x3e4e9e003f6ba956));
      clear_neon_saturated();
      //  Expect: "result" = 0000000000000000
      result = vcvt_u32_f32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u32(result), 0);
      exp = 0;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2041() {

{
   {
      float32x2_t arg1;
      uint32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"cvta\", fnname = \"vcvta_u32_f32\", rettype = \"uint32x2_t\", argtypes = \"[float32x2_t]\", vals = [VectorVal [FloatVal 0.7361352443695068,FloatVal 0.7911092638969421]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_f32(UINT64_C(0x3f4a86233f3c735c));
      clear_neon_saturated();
      //  Expect: "result" = 0000000100000001
      result = vcvta_u32_f32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u32(result), 0);
      exp = UINT64_C(0x0000000100000001);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2042() {

{
   {
      float64x1_t arg1;
      int64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"cvtn\", fnname = \"vcvtn_s64_f64\", rettype = \"int64x1_t\", argtypes = \"[float64x1_t]\", vals = [VectorVal [FloatVal 0.9234095751066375]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_f64(UINT64_C(0x3fed8c923cbcae31));
      clear_neon_saturated();
      //  Expect: "result" = 0000000000000001
      result = vcvtn_s64_f64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s64(result), 0);
      exp = UINT64_C(0x0000000000000001);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2043() {

{
   {
      float64x1_t arg1;
      int64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"cvtp\", fnname = \"vcvtp_s64_f64\", rettype = \"int64x1_t\", argtypes = \"[float64x1_t]\", vals = [VectorVal [FloatVal 0.8591556141834172]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_f64(UINT64_C(0x3feb7e33ea22f657));
      clear_neon_saturated();
      //  Expect: "result" = 0000000000000001
      result = vcvtp_s64_f64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s64(result), 0);
      exp = UINT64_C(0x0000000000000001);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2044() {

{
   {
      float64x1_t arg1;
      int64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"cvtm\", fnname = \"vcvtm_s64_f64\", rettype = \"int64x1_t\", argtypes = \"[float64x1_t]\", vals = [VectorVal [FloatVal 0.8197738869896651]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_f64(UINT64_C(0x3fea3b967257887e));
      clear_neon_saturated();
      //  Expect: "result" = 0000000000000000
      result = vcvtm_s64_f64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s64(result), 0);
      exp = 0;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2045() {

{
   {
      float64x1_t arg1;
      int64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"cvt\", fnname = \"vcvt_s64_f64\", rettype = \"int64x1_t\", argtypes = \"[float64x1_t]\", vals = [VectorVal [FloatVal 0.21553870703683264]], start_saturated = True}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_f64(UINT64_C(0x3fcb96c5b8df66b0));
      set_neon_saturated();
      //  Expect: "result" = 0000000000000000
      result = vcvt_s64_f64(arg1);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s64(result), 0);
      exp = 0;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2046() {

{
   {
      float64x1_t arg1;
      int64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"cvta\", fnname = \"vcvta_s64_f64\", rettype = \"int64x1_t\", argtypes = \"[float64x1_t]\", vals = [VectorVal [FloatVal 0.5789117929727315]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_f64(UINT64_C(0x3fe286720642c577));
      clear_neon_saturated();
      //  Expect: "result" = 0000000000000001
      result = vcvta_s64_f64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s64(result), 0);
      exp = UINT64_C(0x0000000000000001);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2047() {

{
   {
      float64x1_t arg1;
      uint64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"cvtn\", fnname = \"vcvtn_u64_f64\", rettype = \"uint64x1_t\", argtypes = \"[float64x1_t]\", vals = [VectorVal [FloatVal 0.17102038089488603]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_f64(UINT64_C(0x3fc5e3feef724dc8));
      clear_neon_saturated();
      //  Expect: "result" = 0000000000000000
      result = vcvtn_u64_f64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(result, 0);
      exp = 0;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2048() {

{
   {
      float64x1_t arg1;
      uint64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"cvtp\", fnname = \"vcvtp_u64_f64\", rettype = \"uint64x1_t\", argtypes = \"[float64x1_t]\", vals = [VectorVal [FloatVal 0.9882870258520375]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_f64(UINT64_C(0x3fefa00c1ce30f38));
      clear_neon_saturated();
      //  Expect: "result" = 0000000000000001
      result = vcvtp_u64_f64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(result, 0);
      exp = UINT64_C(0x0000000000000001);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2049() {

{
   {
      float64x1_t arg1;
      uint64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"cvtm\", fnname = \"vcvtm_u64_f64\", rettype = \"uint64x1_t\", argtypes = \"[float64x1_t]\", vals = [VectorVal [FloatVal 0.9900164772201036]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_f64(UINT64_C(0x3fefae3709052acb));
      clear_neon_saturated();
      //  Expect: "result" = 0000000000000000
      result = vcvtm_u64_f64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(result, 0);
      exp = 0;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2050() {

{
   {
      float64x1_t arg1;
      uint64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"cvt\", fnname = \"vcvt_u64_f64\", rettype = \"uint64x1_t\", argtypes = \"[float64x1_t]\", vals = [VectorVal [FloatVal 0.38645202332617945]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_f64(UINT64_C(0x3fd8bba1446a2c90));
      clear_neon_saturated();
      //  Expect: "result" = 0000000000000000
      result = vcvt_u64_f64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(result, 0);
      exp = 0;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2051() {

{
   {
      float64x1_t arg1;
      uint64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"cvta\", fnname = \"vcvta_u64_f64\", rettype = \"uint64x1_t\", argtypes = \"[float64x1_t]\", vals = [VectorVal [FloatVal 0.939110819955222]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_f64(UINT64_C(0x3fee0d322260e0a6));
      clear_neon_saturated();
      //  Expect: "result" = 0000000000000001
      result = vcvta_u64_f64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(result, 0);
      exp = UINT64_C(0x0000000000000001);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2052() {

{
   {
      float32x4_t arg1;
      int32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"cvtn\", fnname = \"vcvtnq_s32_f32\", rettype = \"int32x4_t\", argtypes = \"[float32x4_t]\", vals = [VectorVal [FloatVal 0.5585293173789978,FloatVal 0.14318358898162842,FloatVal 0.8123035430908203,FloatVal 0.7551431655883789]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_f32(vcreate_f32(UINT64_C(0x3e129eb83f0efbc7)),
                          vcreate_f32(UINT64_C(0x3f4151103f4ff320)));
      clear_neon_saturated();
      //  Expect: "result" = 00000001000000010000000000000001
      result = vcvtnq_s32_f32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 0);
         exp = UINT64_C(0x0000000000000001);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 1);
         exp = UINT64_C(0x0000000100000001);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2053() {

{
   {
      float32x4_t arg1;
      int32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"cvtp\", fnname = \"vcvtpq_s32_f32\", rettype = \"int32x4_t\", argtypes = \"[float32x4_t]\", vals = [VectorVal [FloatVal 0.7805806994438171,FloatVal 0.623697817325592,FloatVal 0.4629460573196411,FloatVal 7.213342189788818e-2]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_f32(vcreate_f32(UINT64_C(0x3f1faaa93f47d423)),
                          vcreate_f32(UINT64_C(0x3d93bab03eed0744)));
      clear_neon_saturated();
      //  Expect: "result" = 00000001000000010000000100000001
      result = vcvtpq_s32_f32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 0);
         exp = UINT64_C(0x0000000100000001);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 1);
         exp = UINT64_C(0x0000000100000001);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2054() {

{
   {
      float32x4_t arg1;
      int32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"cvtm\", fnname = \"vcvtmq_s32_f32\", rettype = \"int32x4_t\", argtypes = \"[float32x4_t]\", vals = [VectorVal [FloatVal 0.7462215423583984,FloatVal 4.67604398727417e-2,FloatVal 0.9469314217567444,FloatVal 0.47759389877319336]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_f32(vcreate_f32(UINT64_C(0x3d3f87e03f3f0860)),
                          vcreate_f32(UINT64_C(0x3ef487303f726a19)));
      clear_neon_saturated();
      //  Expect: "result" = 00000000000000000000000000000000
      result = vcvtmq_s32_f32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 0);
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 1);
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2055() {

{
   {
      float32x4_t arg1;
      int32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"cvt\", fnname = \"vcvtq_s32_f32\", rettype = \"int32x4_t\", argtypes = \"[float32x4_t]\", vals = [VectorVal [FloatVal 0.6470175385475159,FloatVal 0.466208279132843,FloatVal 0.7711063623428345,FloatVal 0.6245201826095581]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_f32(vcreate_f32(UINT64_C(0x3eeeb2da3f25a2f1)),
                          vcreate_f32(UINT64_C(0x3f1fe08e3f45673a)));
      clear_neon_saturated();
      //  Expect: "result" = 00000000000000000000000000000000
      result = vcvtq_s32_f32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 0);
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 1);
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2056() {

{
   {
      float32x4_t arg1;
      int32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"cvta\", fnname = \"vcvtaq_s32_f32\", rettype = \"int32x4_t\", argtypes = \"[float32x4_t]\", vals = [VectorVal [FloatVal 0.5097063779830933,FloatVal 0.5047057271003723,FloatVal 0.5548288226127625,FloatVal 0.4082711338996887]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_f32(vcreate_f32(UINT64_C(0x3f0134653f027c1e)),
                          vcreate_f32(UINT64_C(0x3ed108ea3f0e0943)));
      clear_neon_saturated();
      //  Expect: "result" = 00000000000000010000000100000001
      result = vcvtaq_s32_f32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 0);
         exp = UINT64_C(0x0000000100000001);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 1);
         exp = UINT64_C(0x0000000000000001);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2057() {

{
   {
      float32x4_t arg1;
      uint32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"cvtn\", fnname = \"vcvtnq_u32_f32\", rettype = \"uint32x4_t\", argtypes = \"[float32x4_t]\", vals = [VectorVal [FloatVal 0.509675145149231,FloatVal 0.2092239260673523,FloatVal 0.754277765750885,FloatVal 0.7725085020065308]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_f32(vcreate_f32(UINT64_C(0x3e563ecc3f027a12)),
                          vcreate_f32(UINT64_C(0x3f45c31e3f411859)));
      clear_neon_saturated();
      //  Expect: "result" = 00000001000000010000000000000001
      result = vcvtnq_u32_f32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 0);
         exp = UINT64_C(0x0000000000000001);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 1);
         exp = UINT64_C(0x0000000100000001);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2058() {

{
   {
      float32x4_t arg1;
      uint32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"cvtp\", fnname = \"vcvtpq_u32_f32\", rettype = \"uint32x4_t\", argtypes = \"[float32x4_t]\", vals = [VectorVal [FloatVal 0.10192674398422241,FloatVal 0.145024836063385,FloatVal 0.9298058748245239,FloatVal 0.6058207750320435]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_f32(vcreate_f32(UINT64_C(0x3e1481643dd0bef8)),
                          vcreate_f32(UINT64_C(0x3f1b17123f6e07c2)));
      clear_neon_saturated();
      //  Expect: "result" = 00000001000000010000000100000001
      result = vcvtpq_u32_f32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 0);
         exp = UINT64_C(0x0000000100000001);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 1);
         exp = UINT64_C(0x0000000100000001);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2059() {

{
   {
      float32x4_t arg1;
      uint32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"cvtm\", fnname = \"vcvtmq_u32_f32\", rettype = \"uint32x4_t\", argtypes = \"[float32x4_t]\", vals = [VectorVal [FloatVal 0.6970366835594177,FloatVal 0.6525145769119263,FloatVal 0.9099963307380676,FloatVal 0.8216570019721985]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_f32(vcreate_f32(UINT64_C(0x3f270b323f3270ff)),
                          vcreate_f32(UINT64_C(0x3f52581d3f68f585)));
      clear_neon_saturated();
      //  Expect: "result" = 00000000000000000000000000000000
      result = vcvtmq_u32_f32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 0);
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 1);
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2060() {

{
   {
      float32x4_t arg1;
      uint32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"cvt\", fnname = \"vcvtq_u32_f32\", rettype = \"uint32x4_t\", argtypes = \"[float32x4_t]\", vals = [VectorVal [FloatVal 0.5653654336929321,FloatVal 0.6623361706733704,FloatVal 0.45396625995635986,FloatVal 0.40291231870651245]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_f32(vcreate_f32(UINT64_C(0x3f298edd3f10bbca)),
                          vcreate_f32(UINT64_C(0x3ece4a863ee86e44)));
      clear_neon_saturated();
      //  Expect: "result" = 00000000000000000000000000000000
      result = vcvtq_u32_f32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 0);
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 1);
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2061() {

{
   {
      float32x4_t arg1;
      uint32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"cvta\", fnname = \"vcvtaq_u32_f32\", rettype = \"uint32x4_t\", argtypes = \"[float32x4_t]\", vals = [VectorVal [FloatVal 0.8478701114654541,FloatVal 0.3474120497703552,FloatVal 0.6161788105964661,FloatVal 0.6191881895065308]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_f32(vcreate_f32(UINT64_C(0x3eb1dffe3f590e04)),
                          vcreate_f32(UINT64_C(0x3f1e831e3f1dbde5)));
      clear_neon_saturated();
      //  Expect: "result" = 00000001000000010000000000000001
      result = vcvtaq_u32_f32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 0);
         exp = UINT64_C(0x0000000000000001);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 1);
         exp = UINT64_C(0x0000000100000001);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2062() {

{
   {
      float64x2_t arg1;
      int64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"cvtn\", fnname = \"vcvtnq_s64_f64\", rettype = \"int64x2_t\", argtypes = \"[float64x2_t]\", vals = [VectorVal [FloatVal 0.28210612264999846,FloatVal 3.0744686863136472e-2]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_f64(vcreate_f64(UINT64_C(0x3fd20e06d6b21e72)),
                          vcreate_f64(UINT64_C(0x3f9f7b8902696700)));
      clear_neon_saturated();
      //  Expect: "result" = 00000000000000000000000000000000
      result = vcvtnq_s64_f64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 0);
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 1);
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2063() {

{
   {
      float64x2_t arg1;
      int64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"cvtp\", fnname = \"vcvtpq_s64_f64\", rettype = \"int64x2_t\", argtypes = \"[float64x2_t]\", vals = [VectorVal [FloatVal 0.11892263696263305,FloatVal 0.23942037916668102]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_f64(vcreate_f64(UINT64_C(0x3fbe71b6c48232f0)),
                          vcreate_f64(UINT64_C(0x3fcea553b54226fc)));
      clear_neon_saturated();
      //  Expect: "result" = 00000000000000010000000000000001
      result = vcvtpq_s64_f64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 0);
         exp = UINT64_C(0x0000000000000001);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 1);
         exp = UINT64_C(0x0000000000000001);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2064() {

{
   {
      float64x2_t arg1;
      int64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"cvtm\", fnname = \"vcvtmq_s64_f64\", rettype = \"int64x2_t\", argtypes = \"[float64x2_t]\", vals = [VectorVal [FloatVal 0.17579162488470312,FloatVal 1.4823765305709724e-2]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_f64(vcreate_f64(UINT64_C(0x3fc6805707e52f18)),
                          vcreate_f64(UINT64_C(0x3f8e5bec19886700)));
      clear_neon_saturated();
      //  Expect: "result" = 00000000000000000000000000000000
      result = vcvtmq_s64_f64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 0);
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 1);
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2065() {

{
   {
      float64x2_t arg1;
      int64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"cvt\", fnname = \"vcvtq_s64_f64\", rettype = \"int64x2_t\", argtypes = \"[float64x2_t]\", vals = [VectorVal [FloatVal 0.6627917961803699,FloatVal 9.483424410748453e-3]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_f64(vcreate_f64(UINT64_C(0x3fe535972414db6f)),
                          vcreate_f64(UINT64_C(0x3f836c0bad960580)));
      clear_neon_saturated();
      //  Expect: "result" = 00000000000000000000000000000000
      result = vcvtq_s64_f64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 0);
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 1);
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2066() {

{
   {
      float64x2_t arg1;
      int64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"cvta\", fnname = \"vcvtaq_s64_f64\", rettype = \"int64x2_t\", argtypes = \"[float64x2_t]\", vals = [VectorVal [FloatVal 0.6049189714379969,FloatVal 0.6311579810346604]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_f64(vcreate_f64(UINT64_C(0x3fe35b7f07e1cc05)),
                          vcreate_f64(UINT64_C(0x3fe4327238e4e776)));
      clear_neon_saturated();
      //  Expect: "result" = 00000000000000010000000000000001
      result = vcvtaq_s64_f64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 0);
         exp = UINT64_C(0x0000000000000001);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 1);
         exp = UINT64_C(0x0000000000000001);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2067() {

{
   {
      float64x2_t arg1;
      uint64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"cvtn\", fnname = \"vcvtnq_u64_f64\", rettype = \"uint64x2_t\", argtypes = \"[float64x2_t]\", vals = [VectorVal [FloatVal 0.2744775446823208,FloatVal 0.7286763610234427]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_f64(vcreate_f64(UINT64_C(0x3fd1910a43796792)),
                          vcreate_f64(UINT64_C(0x3fe75151167ed8e3)));
      clear_neon_saturated();
      //  Expect: "result" = 00000000000000010000000000000000
      result = vcvtnq_u64_f64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 0);
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 1);
         exp = UINT64_C(0x0000000000000001);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2068() {

{
   {
      float64x2_t arg1;
      uint64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"cvtp\", fnname = \"vcvtpq_u64_f64\", rettype = \"uint64x2_t\", argtypes = \"[float64x2_t]\", vals = [VectorVal [FloatVal 0.22814254027950542,FloatVal 0.40943754637316776]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_f64(vcreate_f64(UINT64_C(0x3fcd33c656a9d5d8)),
                          vcreate_f64(UINT64_C(0x3fda343989db57e2)));
      clear_neon_saturated();
      //  Expect: "result" = 00000000000000010000000000000001
      result = vcvtpq_u64_f64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 0);
         exp = UINT64_C(0x0000000000000001);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 1);
         exp = UINT64_C(0x0000000000000001);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2069() {

{
   {
      float64x2_t arg1;
      uint64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"cvtm\", fnname = \"vcvtmq_u64_f64\", rettype = \"uint64x2_t\", argtypes = \"[float64x2_t]\", vals = [VectorVal [FloatVal 0.7886531570604093,FloatVal 0.18655650564957715]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_f64(vcreate_f64(UINT64_C(0x3fe93ca58baec581)),
                          vcreate_f64(UINT64_C(0x3fc7e115654f7c0c)));
      clear_neon_saturated();
      //  Expect: "result" = 00000000000000000000000000000000
      result = vcvtmq_u64_f64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 0);
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 1);
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2070() {

{
   {
      float64x2_t arg1;
      uint64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"cvt\", fnname = \"vcvtq_u64_f64\", rettype = \"uint64x2_t\", argtypes = \"[float64x2_t]\", vals = [VectorVal [FloatVal 0.3776456827091238,FloatVal 0.6937291448882192]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_f64(vcreate_f64(UINT64_C(0x3fd82b58cc2d859a)),
                          vcreate_f64(UINT64_C(0x3fe6330776b2765a)));
      clear_neon_saturated();
      //  Expect: "result" = 00000000000000000000000000000000
      result = vcvtq_u64_f64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 0);
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 1);
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2071() {

{
   {
      float64x2_t arg1;
      uint64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"cvta\", fnname = \"vcvtaq_u64_f64\", rettype = \"uint64x2_t\", argtypes = \"[float64x2_t]\", vals = [VectorVal [FloatVal 0.3739215748924827,FloatVal 0.9972983574850317]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_f64(vcreate_f64(UINT64_C(0x3fd7ee54c1dba658)),
                          vcreate_f64(UINT64_C(0x3fefe9de3eb81659)));
      clear_neon_saturated();
      //  Expect: "result" = 00000000000000010000000000000000
      result = vcvtaq_u64_f64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 0);
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 1);
         exp = UINT64_C(0x0000000000000001);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2072() {

{
   {
      float32_t arg1;
      int32_t result;
      char* str1 = "ReproInfo2 {semantics = \"cvtn\", fnname = \"vcvtns_s32_f32\", rettype = \"int32_t\", argtypes = \"[float32_t]\", vals = [FloatVal 0.11968773603439331], start_saturated = False}";
      int reported = 0;
      int32_t got;
      int32_t exp;
      arg1 = ((float32_t) 0.11968773603439331);
      clear_neon_saturated();
      //  Expect: "result" = 00000000
      result = vcvtns_s32_f32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = 0;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIi32 " Got: %" PRIi32 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2073() {

{
   {
      float32_t arg1;
      int32_t result;
      char* str1 = "ReproInfo2 {semantics = \"cvtp\", fnname = \"vcvtps_s32_f32\", rettype = \"int32_t\", argtypes = \"[float32_t]\", vals = [FloatVal 0.17207300662994385], start_saturated = False}";
      int reported = 0;
      int32_t got;
      int32_t exp;
      arg1 = ((float32_t) 0.17207300662994385);
      clear_neon_saturated();
      //  Expect: "result" = 00000001
      result = vcvtps_s32_f32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = 1;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIi32 " Got: %" PRIi32 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2074() {

{
   {
      float32_t arg1;
      int32_t result;
      char* str1 = "ReproInfo2 {semantics = \"cvtm\", fnname = \"vcvtms_s32_f32\", rettype = \"int32_t\", argtypes = \"[float32_t]\", vals = [FloatVal 0.2062116265296936], start_saturated = False}";
      int reported = 0;
      int32_t got;
      int32_t exp;
      arg1 = ((float32_t) 0.2062116265296936);
      clear_neon_saturated();
      //  Expect: "result" = 00000000
      result = vcvtms_s32_f32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = 0;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIi32 " Got: %" PRIi32 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2075() {

{
   {
      float32_t arg1;
      int32_t result;
      char* str1 = "ReproInfo2 {semantics = \"cvt\", fnname = \"vcvts_s32_f32\", rettype = \"int32_t\", argtypes = \"[float32_t]\", vals = [FloatVal 0.6821726560592651], start_saturated = False}";
      int reported = 0;
      int32_t got;
      int32_t exp;
      arg1 = ((float32_t) 0.6821726560592651);
      clear_neon_saturated();
      //  Expect: "result" = 00000000
      result = vcvts_s32_f32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = 0;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIi32 " Got: %" PRIi32 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2076() {

{
   {
      float32_t arg1;
      int32_t result;
      char* str1 = "ReproInfo2 {semantics = \"cvta\", fnname = \"vcvtas_s32_f32\", rettype = \"int32_t\", argtypes = \"[float32_t]\", vals = [FloatVal 0.424314022064209], start_saturated = False}";
      int reported = 0;
      int32_t got;
      int32_t exp;
      arg1 = ((float32_t) 0.424314022064209);
      clear_neon_saturated();
      //  Expect: "result" = 00000000
      result = vcvtas_s32_f32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = 0;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIi32 " Got: %" PRIi32 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2077() {

{
   {
      float32_t arg1;
      uint32_t result;
      char* str1 = "ReproInfo2 {semantics = \"cvtn\", fnname = \"vcvtns_u32_f32\", rettype = \"uint32_t\", argtypes = \"[float32_t]\", vals = [FloatVal 0.1667569875717163], start_saturated = False}";
      int reported = 0;
      uint32_t got;
      uint32_t exp;
      arg1 = ((float32_t) 0.1667569875717163);
      clear_neon_saturated();
      //  Expect: "result" = 00000000
      result = vcvtns_u32_f32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = 0;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIu32 " Got: %" PRIu32 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2078() {

{
   {
      float32_t arg1;
      uint32_t result;
      char* str1 = "ReproInfo2 {semantics = \"cvtp\", fnname = \"vcvtps_u32_f32\", rettype = \"uint32_t\", argtypes = \"[float32_t]\", vals = [FloatVal 0.5585739016532898], start_saturated = False}";
      int reported = 0;
      uint32_t got;
      uint32_t exp;
      arg1 = ((float32_t) 0.5585739016532898);
      clear_neon_saturated();
      //  Expect: "result" = 00000001
      result = vcvtps_u32_f32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = 1U;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIu32 " Got: %" PRIu32 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2079() {

{
   {
      float32_t arg1;
      uint32_t result;
      char* str1 = "ReproInfo2 {semantics = \"cvtm\", fnname = \"vcvtms_u32_f32\", rettype = \"uint32_t\", argtypes = \"[float32_t]\", vals = [FloatVal 0.8824334740638733], start_saturated = False}";
      int reported = 0;
      uint32_t got;
      uint32_t exp;
      arg1 = ((float32_t) 0.8824334740638733);
      clear_neon_saturated();
      //  Expect: "result" = 00000000
      result = vcvtms_u32_f32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = 0;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIu32 " Got: %" PRIu32 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2080() {

{
   {
      float32_t arg1;
      uint32_t result;
      char* str1 = "ReproInfo2 {semantics = \"cvt\", fnname = \"vcvts_u32_f32\", rettype = \"uint32_t\", argtypes = \"[float32_t]\", vals = [FloatVal 0.36913031339645386], start_saturated = False}";
      int reported = 0;
      uint32_t got;
      uint32_t exp;
      arg1 = ((float32_t) 0.36913031339645386);
      clear_neon_saturated();
      //  Expect: "result" = 00000000
      result = vcvts_u32_f32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = 0;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIu32 " Got: %" PRIu32 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2081() {

{
   {
      float32_t arg1;
      uint32_t result;
      char* str1 = "ReproInfo2 {semantics = \"cvta\", fnname = \"vcvtas_u32_f32\", rettype = \"uint32_t\", argtypes = \"[float32_t]\", vals = [FloatVal 0.8119341135025024], start_saturated = False}";
      int reported = 0;
      uint32_t got;
      uint32_t exp;
      arg1 = ((float32_t) 0.8119341135025024);
      clear_neon_saturated();
      //  Expect: "result" = 00000001
      result = vcvtas_u32_f32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = 1U;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIu32 " Got: %" PRIu32 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2082() {

{
   {
      float64_t arg1;
      int64_t result;
      char* str1 = "ReproInfo2 {semantics = \"cvtn\", fnname = \"vcvtnd_s64_f64\", rettype = \"int64_t\", argtypes = \"[float64_t]\", vals = [FloatVal 0.5691744903896567], start_saturated = False}";
      int reported = 0;
      int64_t got;
      int64_t exp;
      arg1 = 0.5691744903896567;
      clear_neon_saturated();
      //  Expect: "result" = 0000000000000001
      result = vcvtnd_s64_f64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = INT64_C(1);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIi64 " Got: %" PRIi64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2083() {

{
   {
      float64_t arg1;
      int64_t result;
      char* str1 = "ReproInfo2 {semantics = \"cvtp\", fnname = \"vcvtpd_s64_f64\", rettype = \"int64_t\", argtypes = \"[float64_t]\", vals = [FloatVal 0.26021449123934115], start_saturated = False}";
      int reported = 0;
      int64_t got;
      int64_t exp;
      arg1 = 0.26021449123934115;
      clear_neon_saturated();
      //  Expect: "result" = 0000000000000001
      result = vcvtpd_s64_f64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = INT64_C(1);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIi64 " Got: %" PRIi64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2084() {

{
   {
      float64_t arg1;
      int64_t result;
      char* str1 = "ReproInfo2 {semantics = \"cvtm\", fnname = \"vcvtmd_s64_f64\", rettype = \"int64_t\", argtypes = \"[float64_t]\", vals = [FloatVal 0.3235190571470864], start_saturated = False}";
      int reported = 0;
      int64_t got;
      int64_t exp;
      arg1 = 0.3235190571470864;
      clear_neon_saturated();
      //  Expect: "result" = 0000000000000000
      result = vcvtmd_s64_f64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = 0;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIi64 " Got: %" PRIi64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2085() {

{
   {
      float64_t arg1;
      int64_t result;
      char* str1 = "ReproInfo2 {semantics = \"cvt\", fnname = \"vcvtd_s64_f64\", rettype = \"int64_t\", argtypes = \"[float64_t]\", vals = [FloatVal 0.12157859790918568], start_saturated = False}";
      int reported = 0;
      int64_t got;
      int64_t exp;
      arg1 = 0.12157859790918568;
      clear_neon_saturated();
      //  Expect: "result" = 0000000000000000
      result = vcvtd_s64_f64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = 0;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIi64 " Got: %" PRIi64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2086() {

{
   {
      float64_t arg1;
      int64_t result;
      char* str1 = "ReproInfo2 {semantics = \"cvta\", fnname = \"vcvtad_s64_f64\", rettype = \"int64_t\", argtypes = \"[float64_t]\", vals = [FloatVal 0.9249388520572348], start_saturated = False}";
      int reported = 0;
      int64_t got;
      int64_t exp;
      arg1 = 0.9249388520572348;
      clear_neon_saturated();
      //  Expect: "result" = 0000000000000001
      result = vcvtad_s64_f64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = INT64_C(1);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIi64 " Got: %" PRIi64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2087() {

{
   {
      float64_t arg1;
      uint64_t result;
      char* str1 = "ReproInfo2 {semantics = \"cvtn\", fnname = \"vcvtnd_u64_f64\", rettype = \"uint64_t\", argtypes = \"[float64_t]\", vals = [FloatVal 6.668991903209087e-2], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = 6.668991903209087e-2;
      clear_neon_saturated();
      //  Expect: "result" = 0000000000000000
      result = vcvtnd_u64_f64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = 0;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2088() {

{
   {
      float64_t arg1;
      uint64_t result;
      char* str1 = "ReproInfo2 {semantics = \"cvtp\", fnname = \"vcvtpd_u64_f64\", rettype = \"uint64_t\", argtypes = \"[float64_t]\", vals = [FloatVal 0.6728764344257178], start_saturated = True}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = 0.6728764344257178;
      set_neon_saturated();
      //  Expect: "result" = 0000000000000001
      result = vcvtpd_u64_f64(arg1);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      got = result;
      exp = UINT64_C(0x0000000000000001);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2089() {

{
   {
      float64_t arg1;
      uint64_t result;
      char* str1 = "ReproInfo2 {semantics = \"cvtm\", fnname = \"vcvtmd_u64_f64\", rettype = \"uint64_t\", argtypes = \"[float64_t]\", vals = [FloatVal 0.7786779317510848], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = 0.7786779317510848;
      clear_neon_saturated();
      //  Expect: "result" = 0000000000000000
      result = vcvtmd_u64_f64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = 0;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2090() {

{
   {
      float64_t arg1;
      uint64_t result;
      char* str1 = "ReproInfo2 {semantics = \"cvt\", fnname = \"vcvtd_u64_f64\", rettype = \"uint64_t\", argtypes = \"[float64_t]\", vals = [FloatVal 0.48004801865138713], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = 0.48004801865138713;
      clear_neon_saturated();
      //  Expect: "result" = 0000000000000000
      result = vcvtd_u64_f64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = 0;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2091() {

{
   {
      float64_t arg1;
      uint64_t result;
      char* str1 = "ReproInfo2 {semantics = \"cvta\", fnname = \"vcvtad_u64_f64\", rettype = \"uint64_t\", argtypes = \"[float64_t]\", vals = [FloatVal 3.4732618021745543e-3], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = 3.4732618021745543e-3;
      clear_neon_saturated();
      //  Expect: "result" = 0000000000000000
      result = vcvtad_u64_f64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = 0;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2092() {

{
   {
      float32x2_t arg1;
      int32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"cvt\", fnname = \"vcvt_n_s32_f32\", rettype = \"int32x2_t\", argtypes = \"[float32x2_t,__constrange(1,32) int]\", vals = [VectorVal [FloatVal 0.871239423751831,FloatVal 0.24540555477142334],IndexVal 3], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_f32(UINT64_C(0x3e7b4b983f5f098c));
      clear_neon_saturated();
      //  Expect: "result" = 0000000100000006
      result = vcvt_n_s32_f32(arg1, 3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s32(result), 0);
      exp = UINT64_C(0x0000000100000006);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2093() {

{
   {
      float32x2_t arg1;
      uint32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"cvt\", fnname = \"vcvt_n_u32_f32\", rettype = \"uint32x2_t\", argtypes = \"[float32x2_t,__constrange(1,32) int]\", vals = [VectorVal [FloatVal 0.9936008453369141,FloatVal 0.815266489982605],IndexVal 19], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_f32(UINT64_C(0x3f50b54e3f7e5ca0));
      clear_neon_saturated();
      //  Expect: "result" = 000685aa0007f2e5
      result = vcvt_n_u32_f32(arg1, 19);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u32(result), 0);
      exp = UINT64_C(0x000685aa0007f2e5);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2094() {

{
   {
      float64x1_t arg1;
      int64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"cvt\", fnname = \"vcvt_n_s64_f64\", rettype = \"int64x1_t\", argtypes = \"[float64x1_t,__constrange(1,64) int]\", vals = [VectorVal [FloatVal 0.8136277051943112],IndexVal 48], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_f64(UINT64_C(0x3fea093cf81dbb27));
      clear_neon_saturated();
      //  Expect: "result" = 0000d049e7c0edd9
      result = vcvt_n_s64_f64(arg1, 48);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s64(result), 0);
      exp = UINT64_C(0x0000d049e7c0edd9);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2095() {

{
   {
      float64x1_t arg1;
      uint64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"cvt\", fnname = \"vcvt_n_u64_f64\", rettype = \"uint64x1_t\", argtypes = \"[float64x1_t,__constrange(1,64) int]\", vals = [VectorVal [FloatVal 0.367762222026603],IndexVal 45], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_f64(UINT64_C(0x3fd7896a8f13bf4c));
      clear_neon_saturated();
      //  Expect: "result" = 00000bc4b54789df
      result = vcvt_n_u64_f64(arg1, 45);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(result, 0);
      exp = UINT64_C(0x00000bc4b54789df);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2096() {

{
   {
      float32x4_t arg1;
      int32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"cvt\", fnname = \"vcvtq_n_s32_f32\", rettype = \"int32x4_t\", argtypes = \"[float32x4_t,__constrange(1,32) int]\", vals = [VectorVal [FloatVal 0.31630945205688477,FloatVal 0.28483426570892334,FloatVal 0.6928762197494507,FloatVal 0.512869656085968],IndexVal 18], start_saturated = True}";
      int reported = 0;
      arg1 = vcombine_f32(vcreate_f32(UINT64_C(0x3e91d5cc3ea1f350)),
                          vcreate_f32(UINT64_C(0x3f034b6d3f316056)));
      set_neon_saturated();
      //  Expect: "result" = 00020d2d0002c581000123ab000143e6
      result = vcvtq_n_s32_f32(arg1, 18);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 0);
         exp = UINT64_C(0x000123ab000143e6);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 1);
         exp = UINT64_C(0x00020d2d0002c581);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2097() {

{
   {
      float32x4_t arg1;
      uint32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"cvt\", fnname = \"vcvtq_n_u32_f32\", rettype = \"uint32x4_t\", argtypes = \"[float32x4_t,__constrange(1,32) int]\", vals = [VectorVal [FloatVal 0.9974501132965088,FloatVal 8.349341154098511e-2,FloatVal 0.925200343132019,FloatVal 0.34031176567077637],IndexVal 9], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_f32(vcreate_f32(UINT64_C(0x3daafe983f7f58e4)),
                          vcreate_f32(UINT64_C(0x3eae3d583f6cd9ee)));
      clear_neon_saturated();
      //  Expect: "result" = 000000ae000001d90000002a000001fe
      result = vcvtq_n_u32_f32(arg1, 9);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 0);
         exp = UINT64_C(0x0000002a000001fe);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 1);
         exp = UINT64_C(0x000000ae000001d9);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2098() {

{
   {
      float64x2_t arg1;
      int64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"cvt\", fnname = \"vcvtq_n_s64_f64\", rettype = \"int64x2_t\", argtypes = \"[float64x2_t,__constrange(1,64) int]\", vals = [VectorVal [FloatVal 0.26861924833240247,FloatVal 0.2791650110264515],IndexVal 14], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_f64(vcreate_f64(UINT64_C(0x3fd1310ec9aa7b3a)),
                          vcreate_f64(UINT64_C(0x3fd1ddd6ec22f31e)));
      clear_neon_saturated();
      //  Expect: "result" = 00000000000011dd0000000000001131
      result = vcvtq_n_s64_f64(arg1, 14);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 0);
         exp = UINT64_C(0x0000000000001131);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 1);
         exp = UINT64_C(0x00000000000011dd);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2099() {

{
   {
      float64x2_t arg1;
      uint64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"cvt\", fnname = \"vcvtq_n_u64_f64\", rettype = \"uint64x2_t\", argtypes = \"[float64x2_t,__constrange(1,64) int]\", vals = [VectorVal [FloatVal 0.6662299120113494,FloatVal 0.40643942964312774],IndexVal 39], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_f64(vcreate_f64(UINT64_C(0x3fe551c16476951f)),
                          vcreate_f64(UINT64_C(0x3fda031a8687d0ec)));
      clear_neon_saturated();
      //  Expect: "result" = 0000003406350d0f00000055470591da
      result = vcvtq_n_u64_f64(arg1, 39);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 0);
         exp = UINT64_C(0x00000055470591da);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 1);
         exp = UINT64_C(0x0000003406350d0f);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2100() {

{
   {
      float32_t arg1;
      int32_t result;
      char* str1 = "ReproInfo2 {semantics = \"cvt\", fnname = \"vcvts_n_s32_f32\", rettype = \"int32_t\", argtypes = \"[float32_t,__constrange(1,32) int]\", vals = [FloatVal 0.2540767788887024,IndexVal 5], start_saturated = False}";
      int reported = 0;
      int32_t got;
      int32_t exp;
      arg1 = ((float32_t) 0.2540767788887024);
      clear_neon_saturated();
      //  Expect: "result" = 00000008
      result = vcvts_n_s32_f32(arg1, 5);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = 8;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIi32 " Got: %" PRIi32 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2101() {

{
   {
      float32_t arg1;
      uint32_t result;
      char* str1 = "ReproInfo2 {semantics = \"cvt\", fnname = \"vcvts_n_u32_f32\", rettype = \"uint32_t\", argtypes = \"[float32_t,__constrange(1,32) int]\", vals = [FloatVal 0.6846258044242859,IndexVal 3], start_saturated = False}";
      int reported = 0;
      uint32_t got;
      uint32_t exp;
      arg1 = ((float32_t) 0.6846258044242859);
      clear_neon_saturated();
      //  Expect: "result" = 00000005
      result = vcvts_n_u32_f32(arg1, 3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = 5U;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIu32 " Got: %" PRIu32 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2102() {

{
   {
      float64_t arg1;
      int64_t result;
      char* str1 = "ReproInfo2 {semantics = \"cvt\", fnname = \"vcvtd_n_s64_f64\", rettype = \"int64_t\", argtypes = \"[float64_t,__constrange(1,64) int]\", vals = [FloatVal 0.20871967048401263,IndexVal 27], start_saturated = False}";
      int reported = 0;
      int64_t got;
      int64_t exp;
      arg1 = 0.20871967048401263;
      clear_neon_saturated();
      //  Expect: "result" = 0000000001ab7537
      result = vcvtd_n_s64_f64(arg1, 27);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = INT64_C(28013879);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIi64 " Got: %" PRIi64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2103() {

{
   {
      float64_t arg1;
      uint64_t result;
      char* str1 = "ReproInfo2 {semantics = \"cvt\", fnname = \"vcvtd_n_u64_f64\", rettype = \"uint64_t\", argtypes = \"[float64_t,__constrange(1,64) int]\", vals = [FloatVal 0.7932892547444178,IndexVal 33], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = 0.7932892547444178;
      clear_neon_saturated();
      //  Expect: "result" = 00000001962a025a
      result = vcvtd_n_u64_f64(arg1, 33);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = UINT64_C(0x00000001962a025a);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2104() {

{
   {
      float32x2_t arg1;
      float32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"rndn\", fnname = \"vrndn_f32\", rettype = \"float32x2_t\", argtypes = \"[float32x2_t]\", vals = [VectorVal [FloatVal 0.7066782712936401,FloatVal 0.5351850390434265]], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_f32(UINT64_C(0x3f0901e33f34e8de));
      clear_neon_saturated();
      //  Expect: "result" = 3f8000003f800000
      result = vrndn_f32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result, 0);
         exp = ((float32_t) 1.0);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result, 1);
         exp = ((float32_t) 1.0);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
   }
}
}
void dotests_2105() {

{
   {
      float32x2_t arg1;
      float32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"rnda\", fnname = \"vrnda_f32\", rettype = \"float32x2_t\", argtypes = \"[float32x2_t]\", vals = [VectorVal [FloatVal 0.36908382177352905,FloatVal 0.8115676045417786]], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_f32(UINT64_C(0x3f4fc2e53ebcf88e));
      clear_neon_saturated();
      //  Expect: "result" = 3f80000059800000
      result = vrnda_f32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result, 0);
         exp = ((float32_t) 0.0);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result, 1);
         exp = ((float32_t) 1.0);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
   }
}
}
void dotests_2106() {

{
   {
      float32x2_t arg1;
      float32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"rndp\", fnname = \"vrndp_f32\", rettype = \"float32x2_t\", argtypes = \"[float32x2_t]\", vals = [VectorVal [FloatVal 0.5780921578407288,FloatVal 0.7428207993507385]], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_f32(UINT64_C(0x3f3e29813f13fdd9));
      clear_neon_saturated();
      //  Expect: "result" = 3f8000003f800000
      result = vrndp_f32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result, 0);
         exp = ((float32_t) 1.0);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result, 1);
         exp = ((float32_t) 1.0);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
   }
}
}
void dotests_2107() {

{
   {
      float32x2_t arg1;
      float32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"rndm\", fnname = \"vrndm_f32\", rettype = \"float32x2_t\", argtypes = \"[float32x2_t]\", vals = [VectorVal [FloatVal 0.5992525815963745,FloatVal 0.9265722036361694]], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_f32(UINT64_C(0x3f6d33d63f19689e));
      clear_neon_saturated();
      //  Expect: "result" = 5980000059800000
      result = vrndm_f32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result, 0);
         exp = ((float32_t) 0.0);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result, 1);
         exp = ((float32_t) 0.0);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
   }
}
}
void dotests_2108() {

{
   {
      float32x2_t arg1;
      float32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"rndx\", fnname = \"vrndx_f32\", rettype = \"float32x2_t\", argtypes = \"[float32x2_t]\", vals = [VectorVal [FloatVal 9.30904746055603e-2,FloatVal 0.8495235443115234]], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_f32(UINT64_C(0x3f597a603dbea638));
      clear_neon_saturated();
      //  Expect: "result" = 3f80000059800000
      result = vrndx_f32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result, 0);
         exp = ((float32_t) 0.0);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result, 1);
         exp = ((float32_t) 1.0);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
   }
}
}
void dotests_2109() {

{
   {
      float32x2_t arg1;
      float32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"rnd\", fnname = \"vrnd_f32\", rettype = \"float32x2_t\", argtypes = \"[float32x2_t]\", vals = [VectorVal [FloatVal 0.9760465621948242,FloatVal 0.17123037576675415]], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_f32(UINT64_C(0x3e2f57043f79de30));
      clear_neon_saturated();
      //  Expect: "result" = 5980000059800000
      result = vrnd_f32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result, 0);
         exp = ((float32_t) 0.0);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result, 1);
         exp = ((float32_t) 0.0);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
   }
}
}
void dotests_2110() {

{
   {
      float32x2_t arg1;
      float32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"rndi\", fnname = \"vrndi_f32\", rettype = \"float32x2_t\", argtypes = \"[float32x2_t]\", vals = [VectorVal [FloatVal 0.9103354215621948,FloatVal 0.5812215805053711]], start_saturated = True}";
      int reported = 0;
      arg1 = vcreate_f32(UINT64_C(0x3f14caf03f690bbe));
      set_neon_saturated();
      //  Expect: "result" = 3f8000003f800000
      result = vrndi_f32(arg1);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result, 0);
         exp = ((float32_t) 1.0);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result, 1);
         exp = ((float32_t) 1.0);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
   }
}
}
void dotests_2111() {

{
   {
      float64x1_t arg1;
      float64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"rndn\", fnname = \"vrndn_f64\", rettype = \"float64x1_t\", argtypes = \"[float64x1_t]\", vals = [VectorVal [FloatVal 0.4906689523992166]], start_saturated = False}";
      int reported = 0;
      float64_t got;
      float64_t exp;
      arg1 = vcreate_f64(UINT64_C(0x3fdf671ebfede6de));
      clear_neon_saturated();
      //  Expect: "result" = 4330000000000000
      result = vrndn_f64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_f64(result, 0);
      exp = 0.0;
      if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
         }
   }
}
}
void dotests_2112() {

{
   {
      float64x1_t arg1;
      float64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"rnda\", fnname = \"vrnda_f64\", rettype = \"float64x1_t\", argtypes = \"[float64x1_t]\", vals = [VectorVal [FloatVal 0.24987588244934889]], start_saturated = False}";
      int reported = 0;
      float64_t got;
      float64_t exp;
      arg1 = vcreate_f64(UINT64_C(0x3fcffbeed396ec8c));
      clear_neon_saturated();
      //  Expect: "result" = 4330000000000000
      result = vrnda_f64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_f64(result, 0);
      exp = 0.0;
      if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
         }
   }
}
}
void dotests_2113() {

{
   {
      float64x1_t arg1;
      float64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"rndp\", fnname = \"vrndp_f64\", rettype = \"float64x1_t\", argtypes = \"[float64x1_t]\", vals = [VectorVal [FloatVal 0.1854952281810709]], start_saturated = False}";
      int reported = 0;
      float64_t got;
      float64_t exp;
      arg1 = vcreate_f64(UINT64_C(0x3fc7be4ec14d0660));
      clear_neon_saturated();
      //  Expect: "result" = 3ff0000000000000
      result = vrndp_f64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_f64(result, 0);
      exp = 1.0;
      if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
         }
   }
}
}
void dotests_2114() {

{
   {
      float64x1_t arg1;
      float64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"rndm\", fnname = \"vrndm_f64\", rettype = \"float64x1_t\", argtypes = \"[float64x1_t]\", vals = [VectorVal [FloatVal 8.456979089353012e-2]], start_saturated = False}";
      int reported = 0;
      float64_t got;
      float64_t exp;
      arg1 = vcreate_f64(UINT64_C(0x3fb5a65da61e0570));
      clear_neon_saturated();
      //  Expect: "result" = 4330000000000000
      result = vrndm_f64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_f64(result, 0);
      exp = 0.0;
      if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
         }
   }
}
}
void dotests_2115() {

{
   {
      float64x1_t arg1;
      float64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"rndx\", fnname = \"vrndx_f64\", rettype = \"float64x1_t\", argtypes = \"[float64x1_t]\", vals = [VectorVal [FloatVal 6.840425651096382e-2]], start_saturated = False}";
      int reported = 0;
      float64_t got;
      float64_t exp;
      arg1 = vcreate_f64(UINT64_C(0x3fb182f0fc9f2d48));
      clear_neon_saturated();
      //  Expect: "result" = 4330000000000000
      result = vrndx_f64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_f64(result, 0);
      exp = 0.0;
      if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
         }
   }
}
}
void dotests_2116() {

{
   {
      float64x1_t arg1;
      float64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"rnd\", fnname = \"vrnd_f64\", rettype = \"float64x1_t\", argtypes = \"[float64x1_t]\", vals = [VectorVal [FloatVal 0.7047599485038183]], start_saturated = False}";
      int reported = 0;
      float64_t got;
      float64_t exp;
      arg1 = vcreate_f64(UINT64_C(0x3fe68d64bc4b586c));
      clear_neon_saturated();
      //  Expect: "result" = 4330000000000000
      result = vrnd_f64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_f64(result, 0);
      exp = 0.0;
      if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
         }
   }
}
}
void dotests_2117() {

{
   {
      float64x1_t arg1;
      float64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"rndi\", fnname = \"vrndi_f64\", rettype = \"float64x1_t\", argtypes = \"[float64x1_t]\", vals = [VectorVal [FloatVal 0.45486074921678255]], start_saturated = True}";
      int reported = 0;
      float64_t got;
      float64_t exp;
      arg1 = vcreate_f64(UINT64_C(0x3fdd1c704287b05a));
      set_neon_saturated();
      //  Expect: "result" = 4330000000000000
      result = vrndi_f64(arg1);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      got = vget_lane_f64(result, 0);
      exp = 0.0;
      if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
         }
   }
}
}
void dotests_2118() {

{
   {
      float32x4_t arg1;
      float32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"rndn\", fnname = \"vrndnq_f32\", rettype = \"float32x4_t\", argtypes = \"[float32x4_t]\", vals = [VectorVal [FloatVal 0.6695497035980225,FloatVal 0.6476579904556274,FloatVal 0.4234902262687683,FloatVal 0.46762561798095703]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_f32(vcreate_f32(UINT64_C(0x3f25ccea3f2b679c)),
                          vcreate_f32(UINT64_C(0x3eef6ca03ed8d3b6)));
      clear_neon_saturated();
      //  Expect: "result" = 59800000598000003f8000003f800000
      result = vrndnq_f32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 0);
         exp = ((float32_t) 1.0);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 1);
         exp = ((float32_t) 1.0);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 2);
         exp = ((float32_t) 0.0);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 2 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 3);
         exp = ((float32_t) 0.0);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 3 ", exp, got);
            }
      }
   }
}
}
void dotests_2119() {

{
   {
      float32x4_t arg1;
      float32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"rnda\", fnname = \"vrndaq_f32\", rettype = \"float32x4_t\", argtypes = \"[float32x4_t]\", vals = [VectorVal [FloatVal 0.31296253204345703,FloatVal 0.36066728830337524,FloatVal 0.5746800303459167,FloatVal 0.955004096031189]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_f32(vcreate_f32(UINT64_C(0x3eb8a9623ea03ca0)),
                          vcreate_f32(UINT64_C(0x3f747b263f131e3b)));
      clear_neon_saturated();
      //  Expect: "result" = 3f8000003f8000005980000059800000
      result = vrndaq_f32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 0);
         exp = ((float32_t) 0.0);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 1);
         exp = ((float32_t) 0.0);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 2);
         exp = ((float32_t) 1.0);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 2 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 3);
         exp = ((float32_t) 1.0);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 3 ", exp, got);
            }
      }
   }
}
}
void dotests_2120() {

{
   {
      float32x4_t arg1;
      float32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"rndp\", fnname = \"vrndpq_f32\", rettype = \"float32x4_t\", argtypes = \"[float32x4_t]\", vals = [VectorVal [FloatVal 0.351009726524353,FloatVal 0.6559213399887085,FloatVal 0.9614934921264648,FloatVal 0.2877298593521118]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_f32(vcreate_f32(UINT64_C(0x3f27ea763eb3b78c)),
                          vcreate_f32(UINT64_C(0x3e9351543f762470)));
      clear_neon_saturated();
      //  Expect: "result" = 3f8000003f8000003f8000003f800000
      result = vrndpq_f32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 0);
         exp = ((float32_t) 1.0);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 1);
         exp = ((float32_t) 1.0);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 2);
         exp = ((float32_t) 1.0);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 2 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 3);
         exp = ((float32_t) 1.0);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 3 ", exp, got);
            }
      }
   }
}
}
void dotests_2121() {

{
   {
      float32x4_t arg1;
      float32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"rndm\", fnname = \"vrndmq_f32\", rettype = \"float32x4_t\", argtypes = \"[float32x4_t]\", vals = [VectorVal [FloatVal 0.10803425312042236,FloatVal 0.8627870082855225,FloatVal 0.18774431943893433,FloatVal 0.5026786923408508]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_f32(vcreate_f32(UINT64_C(0x3f5cdf9c3ddd4110)),
                          vcreate_f32(UINT64_C(0x3f00af8d3e40400c)));
      clear_neon_saturated();
      //  Expect: "result" = 59800000598000005980000059800000
      result = vrndmq_f32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 0);
         exp = ((float32_t) 0.0);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 1);
         exp = ((float32_t) 0.0);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 2);
         exp = ((float32_t) 0.0);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 2 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 3);
         exp = ((float32_t) 0.0);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 3 ", exp, got);
            }
      }
   }
}
}
void dotests_2122() {

{
   {
      float32x4_t arg1;
      float32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"rndx\", fnname = \"vrndxq_f32\", rettype = \"float32x4_t\", argtypes = \"[float32x4_t]\", vals = [VectorVal [FloatVal 0.42823272943496704,FloatVal 0.6548666954040527,FloatVal 0.6604217886924744,FloatVal 0.3066054582595825]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_f32(vcreate_f32(UINT64_C(0x3f27a5583edb4152)),
                          vcreate_f32(UINT64_C(0x3e9cfb643f291167)));
      clear_neon_saturated();
      //  Expect: "result" = 598000003f8000003f80000059800000
      result = vrndxq_f32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 0);
         exp = ((float32_t) 0.0);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 1);
         exp = ((float32_t) 1.0);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 2);
         exp = ((float32_t) 1.0);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 2 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 3);
         exp = ((float32_t) 0.0);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 3 ", exp, got);
            }
      }
   }
}
}
void dotests_2123() {

{
   {
      float32x4_t arg1;
      float32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"rnd\", fnname = \"vrndq_f32\", rettype = \"float32x4_t\", argtypes = \"[float32x4_t]\", vals = [VectorVal [FloatVal 0.4615090489387512,FloatVal 0.5219177603721619,FloatVal 0.8520010709762573,FloatVal 0.8403052687644958]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_f32(vcreate_f32(UINT64_C(0x3f059c673eec4aea)),
                          vcreate_f32(UINT64_C(0x3f571e3f3f5a1cbe)));
      clear_neon_saturated();
      //  Expect: "result" = 59800000598000005980000059800000
      result = vrndq_f32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 0);
         exp = ((float32_t) 0.0);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 1);
         exp = ((float32_t) 0.0);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 2);
         exp = ((float32_t) 0.0);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 2 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 3);
         exp = ((float32_t) 0.0);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 3 ", exp, got);
            }
      }
   }
}
}
void dotests_2124() {

{
   {
      float32x4_t arg1;
      float32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"rndi\", fnname = \"vrndiq_f32\", rettype = \"float32x4_t\", argtypes = \"[float32x4_t]\", vals = [VectorVal [FloatVal 0.5385107398033142,FloatVal 0.3276677131652832,FloatVal 0.22091633081436157,FloatVal 0.6000685691833496]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_f32(vcreate_f32(UINT64_C(0x3ea7c4103f09dbd7)),
                          vcreate_f32(UINT64_C(0x3f199e183e6237e4)));
      clear_neon_saturated();
      //  Expect: "result" = 3f80000059800000598000003f800000
      result = vrndiq_f32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 0);
         exp = ((float32_t) 1.0);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 1);
         exp = ((float32_t) 0.0);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 2);
         exp = ((float32_t) 0.0);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 2 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 3);
         exp = ((float32_t) 1.0);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 3 ", exp, got);
            }
      }
   }
}
}
void dotests_2125() {

{
   {
      float64x2_t arg1;
      float64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"rndn\", fnname = \"vrndnq_f64\", rettype = \"float64x2_t\", argtypes = \"[float64x2_t]\", vals = [VectorVal [FloatVal 3.8177169211097595e-2,FloatVal 0.5615956577429478]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_f64(vcreate_f64(UINT64_C(0x3fa38bf53a6e58f0)),
                          vcreate_f64(UINT64_C(0x3fe1f89774f29c39)));
      clear_neon_saturated();
      //  Expect: "result" = 3ff00000000000004330000000000000
      result = vrndnq_f64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float64_t got;
         float64_t exp;
         got = vgetq_lane_f64(result, 0);
         exp = 0.0;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float64_t got;
         float64_t exp;
         got = vgetq_lane_f64(result, 1);
         exp = 1.0;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
   }
}
}
void dotests_2126() {

{
   {
      float64x2_t arg1;
      float64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"rnda\", fnname = \"vrndaq_f64\", rettype = \"float64x2_t\", argtypes = \"[float64x2_t]\", vals = [VectorVal [FloatVal 0.19353638197238154,FloatVal 0.5765416685076796]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_f64(vcreate_f64(UINT64_C(0x3fc8c5ccd7942a5c)),
                          vcreate_f64(UINT64_C(0x3fe273078360b23c)));
      clear_neon_saturated();
      //  Expect: "result" = 3ff00000000000004330000000000000
      result = vrndaq_f64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float64_t got;
         float64_t exp;
         got = vgetq_lane_f64(result, 0);
         exp = 0.0;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float64_t got;
         float64_t exp;
         got = vgetq_lane_f64(result, 1);
         exp = 1.0;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
   }
}
}
void dotests_2127() {

{
   {
      float64x2_t arg1;
      float64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"rndp\", fnname = \"vrndpq_f64\", rettype = \"float64x2_t\", argtypes = \"[float64x2_t]\", vals = [VectorVal [FloatVal 0.665440776615449,FloatVal 0.3236701150763741]], start_saturated = True}";
      int reported = 0;
      arg1 = vcombine_f64(vcreate_f64(UINT64_C(0x3fe54b4a749f9f4b)),
                          vcreate_f64(UINT64_C(0x3fd4b702dbbc8470)));
      set_neon_saturated();
      //  Expect: "result" = 3ff00000000000003ff0000000000000
      result = vrndpq_f64(arg1);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      {
         float64_t got;
         float64_t exp;
         got = vgetq_lane_f64(result, 0);
         exp = 1.0;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float64_t got;
         float64_t exp;
         got = vgetq_lane_f64(result, 1);
         exp = 1.0;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
   }
}
}
void dotests_2128() {

{
   {
      float64x2_t arg1;
      float64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"rndm\", fnname = \"vrndmq_f64\", rettype = \"float64x2_t\", argtypes = \"[float64x2_t]\", vals = [VectorVal [FloatVal 0.8573495857388708,FloatVal 0.3112542482010855]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_f64(vcreate_f64(UINT64_C(0x3feb6f6865ff9a67)),
                          vcreate_f64(UINT64_C(0x3fd3eb96f030f152)));
      clear_neon_saturated();
      //  Expect: "result" = 43300000000000004330000000000000
      result = vrndmq_f64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float64_t got;
         float64_t exp;
         got = vgetq_lane_f64(result, 0);
         exp = 0.0;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float64_t got;
         float64_t exp;
         got = vgetq_lane_f64(result, 1);
         exp = 0.0;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
   }
}
}
void dotests_2129() {

{
   {
      float64x2_t arg1;
      float64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"rndx\", fnname = \"vrndxq_f64\", rettype = \"float64x2_t\", argtypes = \"[float64x2_t]\", vals = [VectorVal [FloatVal 5.0849556214450975e-2,FloatVal 0.6468751771566746]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_f64(vcreate_f64(UINT64_C(0x3faa08f3f9ea1390)),
                          vcreate_f64(UINT64_C(0x3fe4b333924f6d8f)));
      clear_neon_saturated();
      //  Expect: "result" = 3ff00000000000004330000000000000
      result = vrndxq_f64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float64_t got;
         float64_t exp;
         got = vgetq_lane_f64(result, 0);
         exp = 0.0;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float64_t got;
         float64_t exp;
         got = vgetq_lane_f64(result, 1);
         exp = 1.0;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
   }
}
}
void dotests_2130() {

{
   {
      float64x2_t arg1;
      float64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"rnd\", fnname = \"vrndq_f64\", rettype = \"float64x2_t\", argtypes = \"[float64x2_t]\", vals = [VectorVal [FloatVal 7.057436978846154e-2,FloatVal 0.6042647275722711]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_f64(vcreate_f64(UINT64_C(0x3fb21129722d6070)),
                          vcreate_f64(UINT64_C(0x3fe35622fb61937d)));
      clear_neon_saturated();
      //  Expect: "result" = 43300000000000004330000000000000
      result = vrndq_f64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float64_t got;
         float64_t exp;
         got = vgetq_lane_f64(result, 0);
         exp = 0.0;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float64_t got;
         float64_t exp;
         got = vgetq_lane_f64(result, 1);
         exp = 0.0;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
   }
}
}
void dotests_2131() {

{
   {
      float64x2_t arg1;
      float64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"rndi\", fnname = \"vrndiq_f64\", rettype = \"float64x2_t\", argtypes = \"[float64x2_t]\", vals = [VectorVal [FloatVal 0.33260702650509744,FloatVal 5.938841599784306e-2]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_f64(vcreate_f64(UINT64_C(0x3fd5496efb5096b6)),
                          vcreate_f64(UINT64_C(0x3fae682890f1a740)));
      clear_neon_saturated();
      //  Expect: "result" = 43300000000000004330000000000000
      result = vrndiq_f64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float64_t got;
         float64_t exp;
         got = vgetq_lane_f64(result, 0);
         exp = 0.0;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float64_t got;
         float64_t exp;
         got = vgetq_lane_f64(result, 1);
         exp = 0.0;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
   }
}
}
void dotests_2132() {

{
   {
      int64x1_t arg1;
      float64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"cvt\", fnname = \"vcvt_f64_s64\", rettype = \"float64x1_t\", argtypes = \"[int64x1_t]\", vals = [VectorVal [IntegerVal 8364732618251370496]], start_saturated = False}";
      int reported = 0;
      float64_t got;
      float64_t exp;
      arg1 = vcreate_s64(UINT64_C(0x74157fff7fff0000));
      clear_neon_saturated();
      //  Expect: "result" = 43dd055fffdfffc0
      result = vcvt_f64_s64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_f64(result, 0);
      exp = 8.36473261825137e18;
      if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
         }
   }
}
}
void dotests_2133() {

{
   {
      uint64x1_t arg1;
      float64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"cvt\", fnname = \"vcvt_f64_u64\", rettype = \"float64x1_t\", argtypes = \"[uint64x1_t]\", vals = [VectorVal [IntegerVal 2568046521354330860]], start_saturated = False}";
      int reported = 0;
      float64_t got;
      float64_t exp;
      arg1 = vcreate_u64(UINT64_C(0x23a388b48000a2ec));
      clear_neon_saturated();
      //  Expect: "result" = 43c1d1c45a400051
      result = vcvt_f64_u64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_f64(result, 0);
      exp = 2.5680465213543306e18;
      if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
         }
   }
}
}
void dotests_2134() {

{
   {
      int64x2_t arg1;
      float64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"cvt\", fnname = \"vcvtq_f64_s64\", rettype = \"float64x2_t\", argtypes = \"[int64x2_t]\", vals = [VectorVal [IntegerVal (-9223372034707324928),IntegerVal 8675762469664129024]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s64(vcreate_s64(UINT64_C(0x800000007fff8000)),
                          vcreate_s64(UINT64_C(0x78667fffffff0000)));
      clear_neon_saturated();
      //  Expect: "result" = 43de199fffffffc0c3dfffffffe00020
      result = vcvtq_f64_s64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float64_t got;
         float64_t exp;
         got = vgetq_lane_f64(result, 0);
         exp = -9.223372034707325e18;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float64_t got;
         float64_t exp;
         got = vgetq_lane_f64(result, 1);
         exp = 8.675762469664129e18;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
   }
}
}
void dotests_2135() {

{
   {
      uint64x2_t arg1;
      float64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"cvt\", fnname = \"vcvtq_f64_u64\", rettype = \"float64x2_t\", argtypes = \"[uint64x2_t]\", vals = [VectorVal [IntegerVal 9223512770048229375,IntegerVal 18446462600901591040]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u64(vcreate_u64(UINT64_C(0x80007fff0000ffff)),
                          vcreate_u64(UINT64_C(0xffff000081448000)));
      clear_neon_saturated();
      //  Expect: "result" = 43efffe00010289043e0000fffe00020
      result = vcvtq_f64_u64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float64_t got;
         float64_t exp;
         got = vgetq_lane_f64(result, 0);
         exp = 9.22351277004823e18;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float64_t got;
         float64_t exp;
         got = vgetq_lane_f64(result, 1);
         exp = 1.8446462600901591e19;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
   }
}
}
void dotests_2136() {

{
   {
      int32_t arg1;
      float32_t result;
      char* str1 = "ReproInfo2 {semantics = \"cvt\", fnname = \"vcvts_f32_s32\", rettype = \"float32_t\", argtypes = \"[int32_t]\", vals = [IntegerVal 65535], start_saturated = False}";
      int reported = 0;
      float32_t got;
      float32_t exp;
      arg1 = 65535;
      clear_neon_saturated();
      //  Expect: "result" = 477fff00
      result = vcvts_f32_s32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = ((float32_t) 65535.0);
      if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %f Got: %f\n", "   ", exp, got);
         }
   }
}
}
void dotests_2137() {

{
   {
      uint32_t arg1;
      float32_t result;
      char* str1 = "ReproInfo2 {semantics = \"cvt\", fnname = \"vcvts_f32_u32\", rettype = \"float32_t\", argtypes = \"[uint32_t]\", vals = [IntegerVal 2147483647], start_saturated = False}";
      int reported = 0;
      float32_t got;
      float32_t exp;
      arg1 = 2147483647U;
      clear_neon_saturated();
      //  Expect: "result" = 4effffff
      result = vcvts_f32_u32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = ((float32_t) 2.147483647e9);
      if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %f Got: %f\n", "   ", exp, got);
         }
   }
}
}
void dotests_2138() {

{
   {
      int64_t arg1;
      float64_t result;
      char* str1 = "ReproInfo2 {semantics = \"cvt\", fnname = \"vcvtd_f64_s64\", rettype = \"float64_t\", argtypes = \"[int64_t]\", vals = [IntegerVal 140735045468160], start_saturated = False}";
      int reported = 0;
      float64_t got;
      float64_t exp;
      arg1 = INT64_C(140735045468160);
      clear_neon_saturated();
      //  Expect: "result" = 42dfffdb99200000
      result = vcvtd_f64_s64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = 1.4073504546816e14;
      if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %f Got: %f\n", "   ", exp, got);
         }
   }
}
}
void dotests_2139() {

{
   {
      uint64_t arg1;
      float64_t result;
      char* str1 = "ReproInfo2 {semantics = \"cvt\", fnname = \"vcvtd_f64_u64\", rettype = \"float64_t\", argtypes = \"[uint64_t]\", vals = [IntegerVal 0], start_saturated = False}";
      int reported = 0;
      float64_t got;
      float64_t exp;
      arg1 = 0;
      clear_neon_saturated();
      //  Expect: "result" = 4330000000000000
      result = vcvtd_f64_u64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = 0.0;
      if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %f Got: %f\n", "   ", exp, got);
         }
   }
}
}
void dotests_2140() {

{
   {
      int32x2_t arg1;
      float32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"cvt\", fnname = \"vcvt_f32_s32\", rettype = \"float32x2_t\", argtypes = \"[int32x2_t]\", vals = [VectorVal [IntegerVal 738656256,IntegerVal (-1202575408)]], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_s32(UINT64_C(0xb85227d02c070000));
      clear_neon_saturated();
      //  Expect: "result" = ce8f5bb04e301c00
      result = vcvt_f32_s32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result, 0);
         exp = ((float32_t) 7.38656256e8);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result, 1);
         exp = ((float32_t) -1.202575408e9);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
   }
}
}
void dotests_2141() {

{
   {
      uint32x2_t arg1;
      float32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"cvt\", fnname = \"vcvt_f32_u32\", rettype = \"float32x2_t\", argtypes = \"[uint32x2_t]\", vals = [VectorVal [IntegerVal 0,IntegerVal 2147516415]], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_u32(UINT64_C(0x80007fff00000000));
      clear_neon_saturated();
      //  Expect: "result" = 4f00007f59800000
      result = vcvt_f32_u32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result, 0);
         exp = ((float32_t) 0.0);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result, 1);
         exp = ((float32_t) 2.147516415e9);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
   }
}
}
void dotests_2142() {

{
   {
      int32x4_t arg1;
      float32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"cvt\", fnname = \"vcvtq_f32_s32\", rettype = \"float32x4_t\", argtypes = \"[int32x4_t]\", vals = [VectorVal [IntegerVal 2147483647,IntegerVal 14514,IntegerVal 22293,IntegerVal 32767]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s32(vcreate_s32(UINT64_C(0x000038b27fffffff)),
                          vcreate_s32(UINT64_C(0x00007fff00005715)));
      clear_neon_saturated();
      //  Expect: "result" = 46fffe0046ae2a004662c8004effffff
      result = vcvtq_f32_s32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 0);
         exp = ((float32_t) 2.147483647e9);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 1);
         exp = ((float32_t) 14514.0);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 2);
         exp = ((float32_t) 22293.0);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 2 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 3);
         exp = ((float32_t) 32767.0);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 3 ", exp, got);
            }
      }
   }
}
}
void dotests_2143() {

{
   {
      uint32x4_t arg1;
      float32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"cvt\", fnname = \"vcvtq_f32_u32\", rettype = \"float32x4_t\", argtypes = \"[uint32x4_t]\", vals = [VectorVal [IntegerVal 2147516416,IntegerVal 4294934527,IntegerVal 2147516416,IntegerVal 4294934528]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u32(vcreate_u32(UINT64_C(0xffff7fff80008000)),
                          vcreate_u32(UINT64_C(0xffff800080008000)));
      clear_neon_saturated();
      //  Expect: "result" = 4f7fff804f0000804f7fff7f4f000080
      result = vcvtq_f32_u32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 0);
         exp = ((float32_t) 2.147516416e9);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 1);
         exp = ((float32_t) 4.294934527e9);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 2);
         exp = ((float32_t) 2.147516416e9);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 2 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 3);
         exp = ((float32_t) 4.294934528e9);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 3 ", exp, got);
            }
      }
   }
}
}
void dotests_2144() {

{
   {
      int32x2_t arg1;
      float32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"cvt\", fnname = \"vcvt_n_f32_s32\", rettype = \"float32x2_t\", argtypes = \"[int32x2_t,__constrange(1,32) int]\", vals = [VectorVal [IntegerVal 32767,IntegerVal 0],IndexVal 11], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_s32(UINT64_C(0x0000000000007fff));
      clear_neon_saturated();
      //  Expect: "result" = 59800000417ffe00
      result = vcvt_n_f32_s32(arg1, 11);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result, 0);
         exp = ((float32_t) 15.99951171875);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result, 1);
         exp = ((float32_t) 0.0);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
   }
}
}
void dotests_2145() {

{
   {
      uint32x2_t arg1;
      float32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"cvt\", fnname = \"vcvt_n_f32_u32\", rettype = \"float32x2_t\", argtypes = \"[uint32x2_t,__constrange(1,32) int]\", vals = [VectorVal [IntegerVal 2147440886,IntegerVal 2147450880],IndexVal 31], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_u32(UINT64_C(0x7fff80007fff58f6));
      clear_neon_saturated();
      //  Expect: "result" = 3f7fff003f7ffeb1
      result = vcvt_n_f32_u32(arg1, 31);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result, 0);
         exp = ((float32_t) 0.9999800873920321);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result, 1);
         exp = ((float32_t) 0.9999847412109375);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
   }
}
}
void dotests_2146() {

{
   {
      int64x1_t arg1;
      float64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"cvt\", fnname = \"vcvt_n_f64_s64\", rettype = \"float64x1_t\", argtypes = \"[int64x1_t,__constrange(1,64) int]\", vals = [VectorVal [IntegerVal 140739635773440],IndexVal 12], start_saturated = False}";
      int reported = 0;
      float64_t got;
      float64_t exp;
      arg1 = vcreate_s64(UINT64_C(0x000080007fff0000));
      clear_neon_saturated();
      //  Expect: "result" = 4220000fffe00000
      result = vcvt_n_f64_s64(arg1, 12);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_f64(result, 0);
      exp = 3.436026264e10;
      if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
         }
   }
}
}
void dotests_2147() {

{
   {
      uint64x1_t arg1;
      float64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"cvt\", fnname = \"vcvt_n_f64_u64\", rettype = \"float64x1_t\", argtypes = \"[uint64x1_t,__constrange(1,64) int]\", vals = [VectorVal [IntegerVal 216949535604735],IndexVal 47], start_saturated = False}";
      int reported = 0;
      float64_t got;
      float64_t exp;
      arg1 = vcreate_u64(UINT64_C(0x0000c5508000ffff));
      clear_neon_saturated();
      //  Expect: "result" = 3ff8aa10001fffe0
      result = vcvt_n_f64_u64(arg1, 47);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_f64(result, 0);
      exp = 1.5415191655047167;
      if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
         }
   }
}
}
void dotests_2148() {

{
   {
      int32x4_t arg1;
      float32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"cvt\", fnname = \"vcvtq_n_f32_s32\", rettype = \"float32x4_t\", argtypes = \"[int32x4_t,__constrange(1,32) int]\", vals = [VectorVal [IntegerVal 2147418112,IntegerVal 0,IntegerVal 32767,IntegerVal (-1)],IndexVal 9], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s32(vcreate_s32(UINT64_C(0x000000007fff0000)),
                          vcreate_s32(UINT64_C(0xffffffff00007fff)));
      clear_neon_saturated();
      //  Expect: "result" = bb000000427ffe00598000004a7ffe00
      result = vcvtq_n_f32_s32(arg1, 9);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 0);
         exp = ((float32_t) 4194176.0);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 1);
         exp = ((float32_t) 0.0);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 2);
         exp = ((float32_t) 63.998046875);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 2 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 3);
         exp = ((float32_t) -1.953125e-3);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 3 ", exp, got);
            }
      }
   }
}
}
void dotests_2149() {

{
   {
      uint32x4_t arg1;
      float32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"cvt\", fnname = \"vcvtq_n_f32_u32\", rettype = \"float32x4_t\", argtypes = \"[uint32x4_t,__constrange(1,32) int]\", vals = [VectorVal [IntegerVal 1849462617,IntegerVal 4294967295,IntegerVal 3491627007,IntegerVal 4294934527],IndexVal 32], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u32(vcreate_u32(UINT64_C(0xffffffff6e3c8f59)),
                          vcreate_u32(UINT64_C(0xffff7fffd01dffff)));
      clear_neon_saturated();
      //  Expect: "result" = 3f7fff7f3f501dff3f7fffff3edc791e
      result = vcvtq_n_f32_u32(arg1, 32);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 0);
         exp = ((float32_t) 0.43061157152988017);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 1);
         exp = ((float32_t) 0.9999999997671694);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 2);
         exp = ((float32_t) 0.8129577634390444);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 2 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 3);
         exp = ((float32_t) 0.9999923703726381);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 3 ", exp, got);
            }
      }
   }
}
}
void dotests_2150() {

{
   {
      int64x2_t arg1;
      float64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"cvt\", fnname = \"vcvtq_n_f64_s64\", rettype = \"float64x2_t\", argtypes = \"[int64x2_t,__constrange(1,64) int]\", vals = [VectorVal [IntegerVal 140741051449343,IntegerVal (-9223231297218936832)],IndexVal 36], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s64(vcreate_s64(UINT64_C(0x00008000d4607fff)),
                          vcreate_s64(UINT64_C(0x8000800080000000)));
      clear_neon_saturated();
      //  Expect: "result" = c19fffdfffe0000040a0001a8c0fffe0
      result = vcvtq_n_f64_s64(arg1, 36);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float64_t got;
         float64_t exp;
         got = vgetq_lane_f64(result, 0);
         exp = 2048.051849842057;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float64_t got;
         float64_t exp;
         got = vgetq_lane_f64(result, 1);
         exp = -1.3421567996875e8;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
   }
}
}
void dotests_2151() {

{
   {
      uint64x2_t arg1;
      float64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"cvt\", fnname = \"vcvtq_n_f64_u64\", rettype = \"float64x2_t\", argtypes = \"[uint64x2_t,__constrange(1,64) int]\", vals = [VectorVal [IntegerVal 9223190540126748671,IntegerVal 13185132331909791713],IndexVal 64], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u64(vcreate_u64(UINT64_C(0x7fff5aedffff7fff)),
                          vcreate_u64(UINT64_C(0xb6faffff80003fe1)));
      clear_neon_saturated();
      //  Expect: "result" = 3fe6df5ffff000083fdfffd6bb7fffe0
      result = vcvtq_n_f64_u64(arg1, 64);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float64_t got;
         float64_t exp;
         got = vgetq_lane_f64(result, 0);
         exp = 0.4999901610426587;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float64_t got;
         float64_t exp;
         got = vgetq_lane_f64(result, 1);
         exp = 0.7147674559382731;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
   }
}
}
void dotests_2152() {

{
   {
      int32_t arg1;
      float32_t result;
      char* str1 = "ReproInfo2 {semantics = \"cvt\", fnname = \"vcvts_n_f32_s32\", rettype = \"float32_t\", argtypes = \"[int32_t,__constrange(1,32) int]\", vals = [IntegerVal 2147450880,IndexVal 15], start_saturated = False}";
      int reported = 0;
      float32_t got;
      float32_t exp;
      arg1 = 2147450880;
      clear_neon_saturated();
      //  Expect: "result" = 477fff00
      result = vcvts_n_f32_s32(arg1, 15);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = ((float32_t) 65535.0);
      if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %f Got: %f\n", "   ", exp, got);
         }
   }
}
}
void dotests_2153() {

{
   {
      uint32_t arg1;
      float32_t result;
      char* str1 = "ReproInfo2 {semantics = \"cvt\", fnname = \"vcvts_n_f32_u32\", rettype = \"float32_t\", argtypes = \"[uint32_t,__constrange(1,32) int]\", vals = [IntegerVal 2147483647,IndexVal 12], start_saturated = False}";
      int reported = 0;
      float32_t got;
      float32_t exp;
      arg1 = 2147483647U;
      clear_neon_saturated();
      //  Expect: "result" = 48ffffff
      result = vcvts_n_f32_u32(arg1, 12);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = ((float32_t) 524287.9997558594);
      if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %f Got: %f\n", "   ", exp, got);
         }
   }
}
}
void dotests_2154() {

{
   {
      int64_t arg1;
      float64_t result;
      char* str1 = "ReproInfo2 {semantics = \"cvt\", fnname = \"vcvtd_n_f64_s64\", rettype = \"float64_t\", argtypes = \"[int64_t,__constrange(1,64) int]\", vals = [IntegerVal (-1082621953),IndexVal 56], start_saturated = False}";
      int reported = 0;
      float64_t got;
      float64_t exp;
      arg1 = INT64_C(-1082621953);
      clear_neon_saturated();
      //  Expect: "result" = be5021e000400000
      result = vcvtd_n_f64_s64(arg1, 56);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = -1.5024397739815676e-8;
      if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %f Got: %f\n", "   ", exp, got);
         }
   }
}
}
void dotests_2155() {

{
   {
      uint64_t arg1;
      float64_t result;
      char* str1 = "ReproInfo2 {semantics = \"cvt\", fnname = \"vcvtd_n_f64_u64\", rettype = \"float64_t\", argtypes = \"[uint64_t,__constrange(1,64) int]\", vals = [IntegerVal 18446744071562100735,IndexVal 28], start_saturated = False}";
      int reported = 0;
      float64_t got;
      float64_t exp;
      arg1 = UINT64_C(0xffffffff80007fff);
      clear_neon_saturated();
      //  Expect: "result" = 422ffffffff00010
      result = vcvtd_n_f64_u64(arg1, 28);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = 6.871947672800012e10;
      if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %f Got: %f\n", "   ", exp, got);
         }
   }
}
}
void dotests_2156() {

{
   
}
}
void dotests_2157() {

{
   {
      float64x2_t arg1;
      float32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"cvtx\", fnname = \"vcvt_f32_f64\", rettype = \"float32x2_t\", argtypes = \"[float64x2_t]\", vals = [VectorVal [FloatVal 0.6496309186177347,FloatVal 0.29743580228125566]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_f64(vcreate_f64(UINT64_C(0x3fe4c9c6c7bde01e)),
                          vcreate_f64(UINT64_C(0x3fd309302cdd47ee)));
      clear_neon_saturated();
      //  Expect: "result" = 3e9849813f264e36
      result = vcvt_f32_f64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result, 0);
         exp = ((float32_t) 0.6496309186177347);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result, 1);
         exp = ((float32_t) 0.29743580228125566);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
   }
}
}
void dotests_2158() {

{
   {
      float64x2_t arg1;
      float32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"cvtx\", fnname = \"vcvtx_f32_f64\", rettype = \"float32x2_t\", argtypes = \"[float64x2_t]\", vals = [VectorVal [FloatVal 0.45323858722409305,FloatVal 0.34627550255102735]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_f64(vcreate_f64(UINT64_C(0x3fdd01dc6b5a6a0e)),
                          vcreate_f64(UINT64_C(0x3fd62960b9b73548)));
      clear_neon_saturated();
      //  Expect: "result" = 3eb14b053ee80ee3
      result = vcvtx_f32_f64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result, 0);
         exp = ((float32_t) 0.45323858722409305);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result, 1);
         exp = ((float32_t) 0.34627550255102735);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
   }
}
}
void dotests_2159() {

{
   
}
}
void dotests_2160() {

{
   {
      float32x2_t arg1;
      float64x2_t arg2;
      float32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"cvtx\", fnname = \"vcvt_high_f32_f64\", rettype = \"float32x4_t\", argtypes = \"[float32x2_t,float64x2_t]\", vals = [VectorVal [FloatVal 0.14093893766403198,FloatVal 7.130593061447144e-2],VectorVal [FloatVal 0.6872147477549646,FloatVal 0.5918575427539386]], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_f32(UINT64_C(0x3d9208d83e10524c));
      arg2 = vcombine_f64(vcreate_f64(UINT64_C(0x3fe5fda9c85df780)),
                          vcreate_f64(UINT64_C(0x3fe2f07f3ac09c5f)));
      clear_neon_saturated();
      //  Expect: "result" = 3f1783f93f2fed4e3d9208d83e10524c
      result = vcvt_high_f32_f64(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 0);
         exp = ((float32_t) 0.14093893766403198);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 1);
         exp = ((float32_t) 7.130593061447144e-2);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 2);
         exp = ((float32_t) 0.6872147477549646);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 2 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 3);
         exp = ((float32_t) 0.5918575427539386);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 3 ", exp, got);
            }
      }
   }
}
}
void dotests_2161() {

{
   {
      float32x2_t arg1;
      float64x2_t arg2;
      float32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"cvtx\", fnname = \"vcvtx_high_f32_f64\", rettype = \"float32x4_t\", argtypes = \"[float32x2_t,float64x2_t]\", vals = [VectorVal [FloatVal 0.39454925060272217,FloatVal 0.7099490165710449],VectorVal [FloatVal 0.21839065990456086,FloatVal 0.927181106424816]], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_f32(UINT64_C(0x3f35bf383eca025c));
      arg2 = vcombine_f64(vcreate_f64(UINT64_C(0x3fcbf439a3055e88)),
                          vcreate_f64(UINT64_C(0x3fedab77b63209ab)));
      clear_neon_saturated();
      //  Expect: "result" = 3f6d5bbd3e5fa1cd3f35bf383eca025c
      result = vcvtx_high_f32_f64(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 0);
         exp = ((float32_t) 0.39454925060272217);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 1);
         exp = ((float32_t) 0.7099490165710449);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 2);
         exp = ((float32_t) 0.21839065990456086);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 2 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 3);
         exp = ((float32_t) 0.927181106424816);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 3 ", exp, got);
            }
      }
   }
}
}
void dotests_2162() {

{
   {
      float64_t arg1;
      float32_t result;
      char* str1 = "ReproInfo2 {semantics = \"cvtx\", fnname = \"vcvtxd_f32_f64\", rettype = \"float32_t\", argtypes = \"[float64_t]\", vals = [FloatVal 0.5209962714723915], start_saturated = False}";
      int reported = 0;
      float32_t got;
      float32_t exp;
      arg1 = 0.5209962714723915;
      clear_neon_saturated();
      //  Expect: "result" = 3f056002
      result = vcvtxd_f32_f64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = ((float32_t) 0.5209962714723915);
      if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %f Got: %f\n", "   ", exp, got);
         }
   }
}
}
void dotests_2163() {

{
   
}
}
void dotests_2164() {

{
   {
      float32x2_t arg1;
      float64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"cvtx\", fnname = \"vcvt_f64_f32\", rettype = \"float64x2_t\", argtypes = \"[float32x2_t]\", vals = [VectorVal [FloatVal 0.36156636476516724,FloatVal 0.4697039723396301]], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_f32(UINT64_C(0x3ef07d0a3eb91f3a));
      clear_neon_saturated();
      //  Expect: "result" = 3fde0fa1400000003fd723e740000000
      result = vcvt_f64_f32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float64_t got;
         float64_t exp;
         got = vgetq_lane_f64(result, 0);
         exp = 0.36156636476516724;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float64_t got;
         float64_t exp;
         got = vgetq_lane_f64(result, 1);
         exp = 0.4697039723396301;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
   }
}
}
void dotests_2165() {

{
   
}
}
void dotests_2166() {

{
   {
      float32x4_t arg1;
      float64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"cvtx\", fnname = \"vcvt_high_f64_f32\", rettype = \"float64x2_t\", argtypes = \"[float32x4_t]\", vals = [VectorVal [FloatVal 0.21405595541000366,FloatVal 0.49428290128707886,FloatVal 3.275507688522339e-2,FloatVal 0.42932432889938354]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_f32(vcreate_f32(UINT64_C(0x3efd12a63e5b317c)),
                          vcreate_f32(UINT64_C(0x3edbd0663d062a30)));
      clear_neon_saturated();
      //  Expect: "result" = 3fdb7a0cc00000003fa0c54600000000
      result = vcvt_high_f64_f32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float64_t got;
         float64_t exp;
         got = vgetq_lane_f64(result, 0);
         exp = 3.275507688522339e-2;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float64_t got;
         float64_t exp;
         got = vgetq_lane_f64(result, 1);
         exp = 0.42932432889938354;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
   }
}
}
void dotests_2167() {

{
   {
      int16x8_t arg1;
      int8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"narrow\", fnname = \"vmovn_s16\", rettype = \"int8x8_t\", argtypes = \"[int16x8_t]\", vals = [VectorVal [IntegerVal 20626,IntegerVal (-32768),IntegerVal 32767,IntegerVal (-32768),IntegerVal (-32768),IntegerVal 0,IntegerVal (-32768),IntegerVal (-11405)]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcombine_s16(vcreate_s16(UINT64_C(0x80007fff80005092)),
                          vcreate_s16(UINT64_C(0xd373800000008000)));
      clear_neon_saturated();
      //  Expect: "result" = 7300000000ff0092
      result = vmovn_s16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s8(result), 0);
      exp = UINT64_C(0x7300000000ff0092);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2168() {

{
   {
      int32x4_t arg1;
      int16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"narrow\", fnname = \"vmovn_s32\", rettype = \"int16x4_t\", argtypes = \"[int32x4_t]\", vals = [VectorVal [IntegerVal 2147418112,IntegerVal (-784334849),IntegerVal (-31377),IntegerVal (-1455369757)]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcombine_s32(vcreate_s32(UINT64_C(0xd13fffff7fff0000)),
                          vcreate_s32(UINT64_C(0xa940d1e3ffff856f)));
      clear_neon_saturated();
      //  Expect: "result" = d1e3856fffff0000
      result = vmovn_s32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s16(result), 0);
      exp = UINT64_C(0xd1e3856fffff0000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2169() {

{
   {
      int64x2_t arg1;
      int32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"narrow\", fnname = \"vmovn_s64\", rettype = \"int32x2_t\", argtypes = \"[int64x2_t]\", vals = [VectorVal [IntegerVal 140741783286245,IntegerVal (-9223360182745038849)]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcombine_s64(vcreate_s64(UINT64_C(0x00008000ffff71e5)),
                          vcreate_s64(UINT64_C(0x80000ac7ffffffff)));
      clear_neon_saturated();
      //  Expect: "result" = ffffffffffff71e5
      result = vmovn_s64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s32(result), 0);
      exp = UINT64_C(0xffffffffffff71e5);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2170() {

{
   {
      uint16x8_t arg1;
      uint8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"narrow\", fnname = \"vmovn_u16\", rettype = \"uint8x8_t\", argtypes = \"[uint16x8_t]\", vals = [VectorVal [IntegerVal 0,IntegerVal 62128,IntegerVal 12411,IntegerVal 19983,IntegerVal 32768,IntegerVal 32768,IntegerVal 65535,IntegerVal 0]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcombine_u16(vcreate_u16(UINT64_C(0x4e0f307bf2b00000)),
                          vcreate_u16(UINT64_C(0x0000ffff80008000)));
      clear_neon_saturated();
      //  Expect: "result" = 00ff00000f7bb000
      result = vmovn_u16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u8(result), 0);
      exp = UINT64_C(0x00ff00000f7bb000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2171() {

{
   {
      uint32x4_t arg1;
      uint16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"narrow\", fnname = \"vmovn_u32\", rettype = \"uint16x4_t\", argtypes = \"[uint32x4_t]\", vals = [VectorVal [IntegerVal 4294901760,IntegerVal 2147516416,IntegerVal 2147516415,IntegerVal 2147502673]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcombine_u32(vcreate_u32(UINT64_C(0x80008000ffff0000)),
                          vcreate_u32(UINT64_C(0x80004a5180007fff)));
      clear_neon_saturated();
      //  Expect: "result" = 4a517fff80000000
      result = vmovn_u32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u16(result), 0);
      exp = UINT64_C(0x4a517fff80000000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2172() {

{
   {
      uint64x2_t arg1;
      uint32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"narrow\", fnname = \"vmovn_u64\", rettype = \"uint32x2_t\", argtypes = \"[uint64x2_t]\", vals = [VectorVal [IntegerVal 18446482548855868553,IntegerVal 9223372033656651763]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcombine_u64(vcreate_u64(UINT64_C(0xffff1224ffff0c89)),
                          vcreate_u64(UINT64_C(0x7fffffff41607ff3)));
      clear_neon_saturated();
      //  Expect: "result" = 41607ff3ffff0c89
      result = vmovn_u64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u32(result), 0);
      exp = UINT64_C(0x41607ff3ffff0c89);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2173() {

{
   {
      int8x8_t arg1;
      int16x8_t arg2;
      int8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"narrow\", fnname = \"vmovn_high_s16\", rettype = \"int8x16_t\", argtypes = \"[int8x8_t,int16x8_t]\", vals = [VectorVal [IntegerVal 0,IntegerVal 0,IntegerVal 127,IntegerVal 127,IntegerVal (-128),IntegerVal 49,IntegerVal (-3),IntegerVal 127],VectorVal [IntegerVal (-32768),IntegerVal (-1),IntegerVal 32767,IntegerVal 0,IntegerVal 19720,IntegerVal 0,IntegerVal (-1),IntegerVal 32767]], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_s8(UINT64_C(0x7ffd31807f7f0000));
      arg2 = vcombine_s16(vcreate_s16(UINT64_C(0x00007fffffff8000)),
                          vcreate_s16(UINT64_C(0x7fffffff00004d08)));
      clear_neon_saturated();
      //  Expect: "result" = ffff000800ffff007ffd31807f7f0000
      result = vmovn_high_s16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result), 0);
         exp = UINT64_C(0x7ffd31807f7f0000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result), 1);
         exp = UINT64_C(0xffff000800ffff00);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2174() {

{
   {
      int16x4_t arg1;
      int32x4_t arg2;
      int16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"narrow\", fnname = \"vmovn_high_s32\", rettype = \"int16x8_t\", argtypes = \"[int16x4_t,int32x4_t]\", vals = [VectorVal [IntegerVal (-32768),IntegerVal (-1),IntegerVal 0,IntegerVal 26573],VectorVal [IntegerVal (-2147483648),IntegerVal 2147418112,IntegerVal (-1501659136),IntegerVal 32767]], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_s16(UINT64_C(0x67cd0000ffff8000));
      arg2 = vcombine_s32(vcreate_s32(UINT64_C(0x7fff000080000000)),
                          vcreate_s32(UINT64_C(0x00007fffa67e8000)));
      clear_neon_saturated();
      //  Expect: "result" = 7fff80000000000067cd0000ffff8000
      result = vmovn_high_s32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 0);
         exp = UINT64_C(0x67cd0000ffff8000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 1);
         exp = UINT64_C(0x7fff800000000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2175() {

{
   {
      int32x2_t arg1;
      int64x2_t arg2;
      int32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"narrow\", fnname = \"vmovn_high_s64\", rettype = \"int32x4_t\", argtypes = \"[int32x2_t,int64x2_t]\", vals = [VectorVal [IntegerVal (-1910767616),IntegerVal 2147450879],VectorVal [IntegerVal 9223231295071518719,IntegerVal 9223231303661355007]], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_s32(UINT64_C(0x7fff7fff8e1c0000));
      arg2 = vcombine_s64(vcreate_s64(UINT64_C(0x7fff7fff0000ffff)),
                          vcreate_s64(UINT64_C(0x7fff8000ffff7fff)));
      clear_neon_saturated();
      //  Expect: "result" = ffff7fff0000ffff7fff7fff8e1c0000
      result = vmovn_high_s64(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 0);
         exp = UINT64_C(0x7fff7fff8e1c0000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 1);
         exp = UINT64_C(0xffff7fff0000ffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2176() {

{
   {
      uint8x8_t arg1;
      uint16x8_t arg2;
      uint8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"narrow\", fnname = \"vmovn_high_u16\", rettype = \"uint8x16_t\", argtypes = \"[uint8x8_t,uint16x8_t]\", vals = [VectorVal [IntegerVal 127,IntegerVal 255,IntegerVal 255,IntegerVal 128,IntegerVal 50,IntegerVal 255,IntegerVal 123,IntegerVal 128],VectorVal [IntegerVal 0,IntegerVal 32768,IntegerVal 14184,IntegerVal 32768,IntegerVal 19005,IntegerVal 21779,IntegerVal 40362,IntegerVal 32767]], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_u8(UINT64_C(0x807bff3280ffff7f));
      arg2 = vcombine_u16(vcreate_u16(UINT64_C(0x8000376880000000)),
                          vcreate_u16(UINT64_C(0x7fff9daa55134a3d)));
      clear_neon_saturated();
      //  Expect: "result" = ffaa133d00680000807bff3280ffff7f
      result = vmovn_high_u16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 0);
         exp = UINT64_C(0x807bff3280ffff7f);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 1);
         exp = UINT64_C(0xffaa133d00680000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2177() {

{
   {
      uint16x4_t arg1;
      uint32x4_t arg2;
      uint16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"narrow\", fnname = \"vmovn_high_u32\", rettype = \"uint16x8_t\", argtypes = \"[uint16x4_t,uint32x4_t]\", vals = [VectorVal [IntegerVal 0,IntegerVal 0,IntegerVal 0,IntegerVal 32767],VectorVal [IntegerVal 4294934527,IntegerVal 2915434496,IntegerVal 2147516416,IntegerVal 4294934527]], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_u16(UINT64_C(0x7fff000000000000));
      arg2 = vcombine_u32(vcreate_u32(UINT64_C(0xadc60000ffff7fff)),
                          vcreate_u32(UINT64_C(0xffff7fff80008000)));
      clear_neon_saturated();
      //  Expect: "result" = 7fff800000007fff7fff000000000000
      result = vmovn_high_u32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 0);
         exp = UINT64_C(0x7fff000000000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 1);
         exp = UINT64_C(0x7fff800000007fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2178() {

{
   {
      uint32x2_t arg1;
      uint64x2_t arg2;
      uint32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"narrow\", fnname = \"vmovn_high_u64\", rettype = \"uint32x4_t\", argtypes = \"[uint32x2_t,uint64x2_t]\", vals = [VectorVal [IntegerVal 2147425821,IntegerVal 2147527003],VectorVal [IntegerVal 9223653511831486463,IntegerVal 18446744071562067968]], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_u32(UINT64_C(0x8000a95b7fff1e1d));
      arg2 = vcombine_u64(vcreate_u64(UINT64_C(0x8000ffffffffffff)),
                          vcreate_u64(UINT64_C(0xffffffff80000000)));
      clear_neon_saturated();
      //  Expect: "result" = 80000000ffffffff8000a95b7fff1e1d
      result = vmovn_high_u64(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 0);
         exp = UINT64_C(0x8000a95b7fff1e1d);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 1);
         exp = UINT64_C(0x80000000ffffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2179() {

{
   {
      int8x8_t arg1;
      int16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"widen\", fnname = \"vmovl_s8\", rettype = \"int16x8_t\", argtypes = \"[int8x8_t]\", vals = [VectorVal [IntegerVal (-71),IntegerVal (-128),IntegerVal 127,IntegerVal (-98),IntegerVal 0,IntegerVal 0,IntegerVal (-128),IntegerVal (-128)]], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_s8(UINT64_C(0x808000009e7f80b9));
      clear_neon_saturated();
      //  Expect: "result" = ff80ff8000000000ff9e007fff80ffb9
      result = vmovl_s8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 0);
         exp = UINT64_C(0xff9e007fff80ffb9);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 1);
         exp = UINT64_C(0xff80ff8000000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2180() {

{
   {
      int16x4_t arg1;
      int32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"widen\", fnname = \"vmovl_s16\", rettype = \"int32x4_t\", argtypes = \"[int16x4_t]\", vals = [VectorVal [IntegerVal (-32768),IntegerVal 0,IntegerVal 0,IntegerVal 0]], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_s16(UINT64_C(0x0000000000008000));
      clear_neon_saturated();
      //  Expect: "result" = 000000000000000000000000ffff8000
      result = vmovl_s16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 0);
         exp = UINT64_C(0x00000000ffff8000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 1);
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2181() {

{
   {
      int32x2_t arg1;
      int64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"widen\", fnname = \"vmovl_s32\", rettype = \"int64x2_t\", argtypes = \"[int32x2_t]\", vals = [VectorVal [IntegerVal 2147457280,IntegerVal 1957240571]], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_s32(UINT64_C(0x74a91efb7fff9900));
      clear_neon_saturated();
      //  Expect: "result" = 0000000074a91efb000000007fff9900
      result = vmovl_s32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 0);
         exp = UINT64_C(0x000000007fff9900);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 1);
         exp = UINT64_C(0x0000000074a91efb);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2182() {

{
   {
      uint8x8_t arg1;
      uint16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"widen\", fnname = \"vmovl_u8\", rettype = \"uint16x8_t\", argtypes = \"[uint8x8_t]\", vals = [VectorVal [IntegerVal 0,IntegerVal 0,IntegerVal 127,IntegerVal 255,IntegerVal 128,IntegerVal 54,IntegerVal 221,IntegerVal 127]], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_u8(UINT64_C(0x7fdd3680ff7f0000));
      clear_neon_saturated();
      //  Expect: "result" = 007f00dd0036008000ff007f00000000
      result = vmovl_u8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 0);
         exp = UINT64_C(0x00ff007f00000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 1);
         exp = UINT64_C(0x007f00dd00360080);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2183() {

{
   {
      uint16x4_t arg1;
      uint32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"widen\", fnname = \"vmovl_u16\", rettype = \"uint32x4_t\", argtypes = \"[uint16x4_t]\", vals = [VectorVal [IntegerVal 38387,IntegerVal 27988,IntegerVal 19448,IntegerVal 32767]], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_u16(UINT64_C(0x7fff4bf86d5495f3));
      clear_neon_saturated();
      //  Expect: "result" = 00007fff00004bf800006d54000095f3
      result = vmovl_u16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 0);
         exp = UINT64_C(0x00006d54000095f3);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 1);
         exp = UINT64_C(0x00007fff00004bf8);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2184() {

{
   {
      uint32x2_t arg1;
      uint64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"widen\", fnname = \"vmovl_u32\", rettype = \"uint64x2_t\", argtypes = \"[uint32x2_t]\", vals = [VectorVal [IntegerVal 4294901760,IntegerVal 2147549183]], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_u32(UINT64_C(0x8000ffffffff0000));
      clear_neon_saturated();
      //  Expect: "result" = 000000008000ffff00000000ffff0000
      result = vmovl_u32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 0);
         exp = UINT64_C(0x00000000ffff0000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 1);
         exp = UINT64_C(0x000000008000ffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2185() {

{
   {
      int8x16_t arg1;
      int16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"widen\", fnname = \"vmovl_high_s8\", rettype = \"int16x8_t\", argtypes = \"[int8x16_t]\", vals = [VectorVal [IntegerVal 47,IntegerVal 33,IntegerVal (-128),IntegerVal (-1),IntegerVal (-1),IntegerVal (-128),IntegerVal 0,IntegerVal (-1),IntegerVal (-128),IntegerVal (-1),IntegerVal 127,IntegerVal 127,IntegerVal 127,IntegerVal (-128),IntegerVal 0,IntegerVal 127]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s8(vcreate_s8(UINT64_C(0xff0080ffff80212f)),
                         vcreate_s8(UINT64_C(0x7f00807f7f7fff80)));
      clear_neon_saturated();
      //  Expect: "result" = 007f0000ff80007f007f007fffffff80
      result = vmovl_high_s8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 0);
         exp = UINT64_C(0x007f007fffffff80);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 1);
         exp = UINT64_C(0x007f0000ff80007f);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2186() {

{
   {
      int16x8_t arg1;
      int32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"widen\", fnname = \"vmovl_high_s16\", rettype = \"int32x4_t\", argtypes = \"[int16x8_t]\", vals = [VectorVal [IntegerVal 0,IntegerVal (-32768),IntegerVal (-32768),IntegerVal (-1),IntegerVal 0,IntegerVal (-1),IntegerVal 32767,IntegerVal 32767]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s16(vcreate_s16(UINT64_C(0xffff800080000000)),
                          vcreate_s16(UINT64_C(0x7fff7fffffff0000)));
      clear_neon_saturated();
      //  Expect: "result" = 00007fff00007fffffffffff00000000
      result = vmovl_high_s16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 0);
         exp = UINT64_C(0xffffffff00000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 1);
         exp = UINT64_C(0x00007fff00007fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2187() {

{
   {
      int32x4_t arg1;
      int64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"widen\", fnname = \"vmovl_high_s32\", rettype = \"int64x2_t\", argtypes = \"[int32x4_t]\", vals = [VectorVal [IntegerVal 1758894232,IntegerVal (-553058305),IntegerVal 65535,IntegerVal 2033057792]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s32(vcreate_s32(UINT64_C(0xdf08ffff68d69898)),
                          vcreate_s32(UINT64_C(0x792e00000000ffff)));
      clear_neon_saturated();
      //  Expect: "result" = 00000000792e0000000000000000ffff
      result = vmovl_high_s32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 0);
         exp = UINT64_C(0x000000000000ffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 1);
         exp = UINT64_C(0x00000000792e0000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2188() {

{
   {
      uint8x16_t arg1;
      uint16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"widen\", fnname = \"vmovl_high_u8\", rettype = \"uint16x8_t\", argtypes = \"[uint8x16_t]\", vals = [VectorVal [IntegerVal 128,IntegerVal 129,IntegerVal 128,IntegerVal 127,IntegerVal 128,IntegerVal 255,IntegerVal 0,IntegerVal 128,IntegerVal 128,IntegerVal 128,IntegerVal 127,IntegerVal 127,IntegerVal 128,IntegerVal 0,IntegerVal 0,IntegerVal 255]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u8(vcreate_u8(UINT64_C(0x8000ff807f808180)),
                         vcreate_u8(UINT64_C(0xff0000807f7f8080)));
      clear_neon_saturated();
      //  Expect: "result" = 00ff000000000080007f007f00800080
      result = vmovl_high_u8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 0);
         exp = UINT64_C(0x007f007f00800080);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 1);
         exp = UINT64_C(0x00ff000000000080);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2189() {

{
   {
      uint16x8_t arg1;
      uint32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"widen\", fnname = \"vmovl_high_u16\", rettype = \"uint32x4_t\", argtypes = \"[uint16x8_t]\", vals = [VectorVal [IntegerVal 32768,IntegerVal 32768,IntegerVal 32767,IntegerVal 32768,IntegerVal 55654,IntegerVal 0,IntegerVal 65535,IntegerVal 32768]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u16(vcreate_u16(UINT64_C(0x80007fff80008000)),
                          vcreate_u16(UINT64_C(0x8000ffff0000d966)));
      clear_neon_saturated();
      //  Expect: "result" = 000080000000ffff000000000000d966
      result = vmovl_high_u16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 0);
         exp = UINT64_C(0x000000000000d966);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 1);
         exp = UINT64_C(0x000080000000ffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2190() {

{
   {
      uint32x4_t arg1;
      uint64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"widen\", fnname = \"vmovl_high_u32\", rettype = \"uint64x2_t\", argtypes = \"[uint32x4_t]\", vals = [VectorVal [IntegerVal 2147516416,IntegerVal 3901390848,IntegerVal 2147516415,IntegerVal 4294901760]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u32(vcreate_u32(UINT64_C(0xe88a800080008000)),
                          vcreate_u32(UINT64_C(0xffff000080007fff)));
      clear_neon_saturated();
      //  Expect: "result" = 00000000ffff00000000000080007fff
      result = vmovl_high_u32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 0);
         exp = UINT64_C(0x0000000080007fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 1);
         exp = UINT64_C(0x00000000ffff0000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2191() {

{
   {
      int16x8_t arg1;
      int8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"saturating_narrow\", fnname = \"vqmovn_s16\", rettype = \"int8x8_t\", argtypes = \"[int16x8_t]\", vals = [VectorVal [IntegerVal (-8592),IntegerVal (-1),IntegerVal 32767,IntegerVal 32767,IntegerVal (-32768),IntegerVal 32767,IntegerVal 0,IntegerVal (-1)]], start_saturated = True}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcombine_s16(vcreate_s16(UINT64_C(0x7fff7fffffffde70)),
                          vcreate_s16(UINT64_C(0xffff00007fff8000)));
      set_neon_saturated();
      //  Expect: "result" = ff007f807f7fff80
      result = vqmovn_s16(arg1);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s8(result), 0);
      exp = UINT64_C(0xff007f807f7fff80);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2192() {

{
   {
      int32x4_t arg1;
      int16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"saturating_narrow\", fnname = \"vqmovn_s32\", rettype = \"int16x4_t\", argtypes = \"[int32x4_t]\", vals = [VectorVal [IntegerVal 2147418112,IntegerVal 2147418112,IntegerVal (-32769),IntegerVal 50481]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcombine_s32(vcreate_s32(UINT64_C(0x7fff00007fff0000)),
                          vcreate_s32(UINT64_C(0x0000c531ffff7fff)));
      clear_neon_saturated();
      //  Expect: "result" = 7fff80007fff7fff
      result = vqmovn_s32(arg1);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s16(result), 0);
      exp = UINT64_C(0x7fff80007fff7fff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2193() {

{
   {
      int64x2_t arg1;
      int32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"saturating_narrow\", fnname = \"vqmovn_s64\", rettype = \"int32x2_t\", argtypes = \"[int64x2_t]\", vals = [VectorVal [IntegerVal (-120304181477376),IntegerVal (-9223231299675488256)]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcombine_s64(vcreate_s64(UINT64_C(0xffff92957fff8000)),
                          vcreate_s64(UINT64_C(0x80007fffed940000)));
      clear_neon_saturated();
      //  Expect: "result" = 8000000080000000
      result = vqmovn_s64(arg1);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s32(result), 0);
      exp = UINT64_C(0x8000000080000000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2194() {

{
   {
      uint16x8_t arg1;
      uint8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"saturating_narrow\", fnname = \"vqmovn_u16\", rettype = \"uint8x8_t\", argtypes = \"[uint16x8_t]\", vals = [VectorVal [IntegerVal 14879,IntegerVal 32767,IntegerVal 38870,IntegerVal 65535,IntegerVal 16175,IntegerVal 65535,IntegerVal 65535,IntegerVal 65535]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcombine_u16(vcreate_u16(UINT64_C(0xffff97d67fff3a1f)),
                          vcreate_u16(UINT64_C(0xffffffffffff3f2f)));
      clear_neon_saturated();
      //  Expect: "result" = ffffffffffffffff
      result = vqmovn_u16(arg1);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u8(result), 0);
      exp = UINT64_C(0xffffffffffffffff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2195() {

{
   {
      uint32x4_t arg1;
      uint16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"saturating_narrow\", fnname = \"vqmovn_u32\", rettype = \"uint16x4_t\", argtypes = \"[uint32x4_t]\", vals = [VectorVal [IntegerVal 4294901760,IntegerVal 2147516416,IntegerVal 4037279743,IntegerVal 2147483648]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcombine_u32(vcreate_u32(UINT64_C(0x80008000ffff0000)),
                          vcreate_u32(UINT64_C(0x80000000f0a3ffff)));
      clear_neon_saturated();
      //  Expect: "result" = ffffffffffffffff
      result = vqmovn_u32(arg1);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u16(result), 0);
      exp = UINT64_C(0xffffffffffffffff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2196() {

{
   {
      uint64x2_t arg1;
      uint32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"saturating_narrow\", fnname = \"vqmovn_u64\", rettype = \"uint32x2_t\", argtypes = \"[uint64x2_t]\", vals = [VectorVal [IntegerVal 268978769330175,IntegerVal 12534365140692205568]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcombine_u64(vcreate_u64(UINT64_C(0x0000f4a27fff7fff)),
                          vcreate_u64(UINT64_C(0xadf302af7fff8000)));
      clear_neon_saturated();
      //  Expect: "result" = ffffffffffffffff
      result = vqmovn_u64(arg1);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u32(result), 0);
      exp = UINT64_C(0xffffffffffffffff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2197() {

{
   {
      int16_t arg1;
      int8_t result;
      char* str1 = "ReproInfo2 {semantics = \"saturating_narrow\", fnname = \"vqmovnh_s16\", rettype = \"int8_t\", argtypes = \"[int16_t]\", vals = [IntegerVal 32767], start_saturated = False}";
      int reported = 0;
      int8_t got;
      int8_t exp;
      arg1 = 32767;
      clear_neon_saturated();
      //  Expect: "result" = 7f
      result = vqmovnh_s16(arg1);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      got = result;
      exp = 127;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2198() {

{
   {
      int32_t arg1;
      int16_t result;
      char* str1 = "ReproInfo2 {semantics = \"saturating_narrow\", fnname = \"vqmovns_s32\", rettype = \"int16_t\", argtypes = \"[int32_t]\", vals = [IntegerVal 32768], start_saturated = False}";
      int reported = 0;
      int16_t got;
      int16_t exp;
      arg1 = 32768;
      clear_neon_saturated();
      //  Expect: "result" = 7fff
      result = vqmovns_s32(arg1);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      got = result;
      exp = 32767;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIi16 " Got: %" PRIi16 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2199() {

{
   {
      int64_t arg1;
      int32_t result;
      char* str1 = "ReproInfo2 {semantics = \"saturating_narrow\", fnname = \"vqmovnd_s64\", rettype = \"int32_t\", argtypes = \"[int64_t]\", vals = [IntegerVal (-7072695372727910401)], start_saturated = False}";
      int reported = 0;
      int32_t got;
      int32_t exp;
      arg1 = INT64_C(-7072695372727910401);
      clear_neon_saturated();
      //  Expect: "result" = 80000000
      result = vqmovnd_s64(arg1);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      got = result;
      exp = (int32_t) 0x80000000;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIi32 " Got: %" PRIi32 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2200() {

{
   {
      uint16_t arg1;
      uint8_t result;
      char* str1 = "ReproInfo2 {semantics = \"saturating_narrow\", fnname = \"vqmovnh_u16\", rettype = \"uint8_t\", argtypes = \"[uint16_t]\", vals = [IntegerVal 65535], start_saturated = False}";
      int reported = 0;
      uint8_t got;
      uint8_t exp;
      arg1 = 65535U;
      clear_neon_saturated();
      //  Expect: "result" = ff
      result = vqmovnh_u16(arg1);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      got = result;
      exp = 255U;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2201() {

{
   {
      uint32_t arg1;
      uint16_t result;
      char* str1 = "ReproInfo2 {semantics = \"saturating_narrow\", fnname = \"vqmovns_u32\", rettype = \"uint16_t\", argtypes = \"[uint32_t]\", vals = [IntegerVal 4294967295], start_saturated = False}";
      int reported = 0;
      uint16_t got;
      uint16_t exp;
      arg1 = 4294967295U;
      clear_neon_saturated();
      //  Expect: "result" = ffff
      result = vqmovns_u32(arg1);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      got = result;
      exp = 65535U;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2202() {

{
   {
      uint64_t arg1;
      uint32_t result;
      char* str1 = "ReproInfo2 {semantics = \"saturating_narrow\", fnname = \"vqmovnd_u64\", rettype = \"uint32_t\", argtypes = \"[uint64_t]\", vals = [IntegerVal 18446744069414649855], start_saturated = False}";
      int reported = 0;
      uint32_t got;
      uint32_t exp;
      arg1 = UINT64_C(0xffffffff0000ffff);
      clear_neon_saturated();
      //  Expect: "result" = ffffffff
      result = vqmovnd_u64(arg1);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      got = result;
      exp = 4294967295U;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIu32 " Got: %" PRIu32 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2203() {

{
   {
      int8x8_t arg1;
      int16x8_t arg2;
      int8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"saturating_narrow\", fnname = \"vqmovn_high_s16\", rettype = \"int8x16_t\", argtypes = \"[int8x8_t,int16x8_t]\", vals = [VectorVal [IntegerVal 127,IntegerVal (-1),IntegerVal 127,IntegerVal (-1),IntegerVal (-1),IntegerVal 0,IntegerVal 127,IntegerVal 107],VectorVal [IntegerVal (-1),IntegerVal (-1),IntegerVal (-32140),IntegerVal (-32768),IntegerVal 0,IntegerVal (-1),IntegerVal (-32768),IntegerVal (-1)]], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_s8(UINT64_C(0x6b7f00ffff7fff7f));
      arg2 = vcombine_s16(vcreate_s16(UINT64_C(0x80008274ffffffff)),
                          vcreate_s16(UINT64_C(0xffff8000ffff0000)));
      clear_neon_saturated();
      //  Expect: "result" = ff80ff008080ffff6b7f00ffff7fff7f
      result = vqmovn_high_s16(arg1, arg2);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result), 0);
         exp = UINT64_C(0x6b7f00ffff7fff7f);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result), 1);
         exp = UINT64_C(0xff80ff008080ffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2204() {

{
   {
      int16x4_t arg1;
      int32x4_t arg2;
      int16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"saturating_narrow\", fnname = \"vqmovn_high_s32\", rettype = \"int16x8_t\", argtypes = \"[int16x4_t,int32x4_t]\", vals = [VectorVal [IntegerVal 27418,IntegerVal (-32768),IntegerVal 0,IntegerVal (-11016)],VectorVal [IntegerVal (-65536),IntegerVal (-32768),IntegerVal 2147483647,IntegerVal 65535]], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_s16(UINT64_C(0xd4f8000080006b1a));
      arg2 = vcombine_s32(vcreate_s32(UINT64_C(0xffff8000ffff0000)),
                          vcreate_s32(UINT64_C(0x0000ffff7fffffff)));
      clear_neon_saturated();
      //  Expect: "result" = 7fff7fff80008000d4f8000080006b1a
      result = vqmovn_high_s32(arg1, arg2);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 0);
         exp = UINT64_C(0xd4f8000080006b1a);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 1);
         exp = UINT64_C(0x7fff7fff80008000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2205() {

{
   {
      int32x2_t arg1;
      int64x2_t arg2;
      int32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"saturating_narrow\", fnname = \"vqmovn_high_s64\", rettype = \"int32x4_t\", argtypes = \"[int32x2_t,int64x2_t]\", vals = [VectorVal [IntegerVal (-2147453040),IntegerVal (-65536)],VectorVal [IntegerVal 2765491646182260735,IntegerVal 281472829292543]], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_s32(UINT64_C(0xffff000080007790));
      arg2 = vcombine_s64(vcreate_s64(UINT64_C(0x266100000000ffff)),
                          vcreate_s64(UINT64_C(0x0000ffff8000ffff)));
      clear_neon_saturated();
      //  Expect: "result" = 7fffffff7fffffffffff000080007790
      result = vqmovn_high_s64(arg1, arg2);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 0);
         exp = UINT64_C(0xffff000080007790);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 1);
         exp = UINT64_C(0x7fffffff7fffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2206() {

{
   {
      uint8x8_t arg1;
      uint16x8_t arg2;
      uint8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"saturating_narrow\", fnname = \"vqmovn_high_u16\", rettype = \"uint8x16_t\", argtypes = \"[uint8x8_t,uint16x8_t]\", vals = [VectorVal [IntegerVal 128,IntegerVal 78,IntegerVal 255,IntegerVal 70,IntegerVal 128,IntegerVal 128,IntegerVal 127,IntegerVal 0],VectorVal [IntegerVal 32767,IntegerVal 65535,IntegerVal 65535,IntegerVal 32767,IntegerVal 32768,IntegerVal 32768,IntegerVal 32767,IntegerVal 39973]], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_u8(UINT64_C(0x007f808046ff4e80));
      arg2 = vcombine_u16(vcreate_u16(UINT64_C(0x7fffffffffff7fff)),
                          vcreate_u16(UINT64_C(0x9c257fff80008000)));
      clear_neon_saturated();
      //  Expect: "result" = ffffffffffffffff007f808046ff4e80
      result = vqmovn_high_u16(arg1, arg2);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 0);
         exp = UINT64_C(0x007f808046ff4e80);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 1);
         exp = UINT64_C(0xffffffffffffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2207() {

{
   {
      uint16x4_t arg1;
      uint32x4_t arg2;
      uint16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"saturating_narrow\", fnname = \"vqmovn_high_u32\", rettype = \"uint16x8_t\", argtypes = \"[uint16x4_t,uint32x4_t]\", vals = [VectorVal [IntegerVal 27235,IntegerVal 0,IntegerVal 32767,IntegerVal 38924],VectorVal [IntegerVal 65535,IntegerVal 2147483647,IntegerVal 2147516416,IntegerVal 2351464447]], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_u16(UINT64_C(0x980c7fff00006a63));
      arg2 = vcombine_u32(vcreate_u32(UINT64_C(0x7fffffff0000ffff)),
                          vcreate_u32(UINT64_C(0x8c287fff80008000)));
      clear_neon_saturated();
      //  Expect: "result" = ffffffffffffffff980c7fff00006a63
      result = vqmovn_high_u32(arg1, arg2);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 0);
         exp = UINT64_C(0x980c7fff00006a63);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 1);
         exp = UINT64_C(0xffffffffffffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2208() {

{
   {
      uint32x2_t arg1;
      uint64x2_t arg2;
      uint32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"saturating_narrow\", fnname = \"vqmovn_high_u64\", rettype = \"uint32x4_t\", argtypes = \"[uint32x2_t,uint64x2_t]\", vals = [VectorVal [IntegerVal 4294901760,IntegerVal 20814],VectorVal [IntegerVal 140739635871744,IntegerVal 9223512770048163840]], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_u32(UINT64_C(0x0000514effff0000));
      arg2 = vcombine_u64(vcreate_u64(UINT64_C(0x0000800080008000)),
                          vcreate_u64(UINT64_C(0x80007fff00000000)));
      clear_neon_saturated();
      //  Expect: "result" = ffffffffffffffff0000514effff0000
      result = vqmovn_high_u64(arg1, arg2);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 0);
         exp = UINT64_C(0x0000514effff0000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 1);
         exp = UINT64_C(0xffffffffffffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2209() {

{
   {
      int16x8_t arg1;
      uint8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"saturating_narrow\", fnname = \"vqmovun_s16\", rettype = \"uint8x8_t\", argtypes = \"[int16x8_t]\", vals = [VectorVal [IntegerVal (-32768),IntegerVal (-32768),IntegerVal 0,IntegerVal (-2671),IntegerVal 1333,IntegerVal (-32768),IntegerVal 6239,IntegerVal (-32768)]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcombine_s16(vcreate_s16(UINT64_C(0xf591000080008000)),
                          vcreate_s16(UINT64_C(0x8000185f80000535)));
      clear_neon_saturated();
      //  Expect: "result" = 00ff00ff00000000
      result = vqmovun_s16(arg1);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u8(result), 0);
      exp = UINT64_C(0x00ff00ff00000000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2210() {

{
   {
      int32x4_t arg1;
      uint16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"saturating_narrow\", fnname = \"vqmovun_s32\", rettype = \"uint16x4_t\", argtypes = \"[int32x4_t]\", vals = [VectorVal [IntegerVal (-1),IntegerVal (-65536),IntegerVal 1714552831,IntegerVal (-1)]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcombine_s32(vcreate_s32(UINT64_C(0xffff0000ffffffff)),
                          vcreate_s32(UINT64_C(0xffffffff6631ffff)));
      clear_neon_saturated();
      //  Expect: "result" = 0000ffff00000000
      result = vqmovun_s32(arg1);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u16(result), 0);
      exp = UINT64_C(0x0000ffff00000000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2211() {

{
   {
      int64x2_t arg1;
      uint32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"saturating_narrow\", fnname = \"vqmovun_s64\", rettype = \"uint32x2_t\", argtypes = \"[int64x2_t]\", vals = [VectorVal [IntegerVal (-9223372034707324929),IntegerVal (-140735340838913)]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcombine_s64(vcreate_s64(UINT64_C(0x800000007fff7fff)),
                          vcreate_s64(UINT64_C(0xffff800080007fff)));
      clear_neon_saturated();
      //  Expect: "result" = 0000000000000000
      result = vqmovun_s64(arg1);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u32(result), 0);
      exp = 0;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2212() {

{
   {
      int16_t arg1;
      uint8_t result;
      char* str1 = "ReproInfo2 {semantics = \"saturating_narrow\", fnname = \"vqmovunh_s16\", rettype = \"uint8_t\", argtypes = \"[int16_t]\", vals = [IntegerVal 32767], start_saturated = False}";
      int reported = 0;
      uint8_t got;
      uint8_t exp;
      arg1 = 32767;
      clear_neon_saturated();
      //  Expect: "result" = ff
      result = vqmovunh_s16(arg1);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      got = result;
      exp = 255U;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2213() {

{
   {
      int32_t arg1;
      uint16_t result;
      char* str1 = "ReproInfo2 {semantics = \"saturating_narrow\", fnname = \"vqmovuns_s32\", rettype = \"uint16_t\", argtypes = \"[int32_t]\", vals = [IntegerVal (-925040640)], start_saturated = False}";
      int reported = 0;
      uint16_t got;
      uint16_t exp;
      arg1 = -925040640;
      clear_neon_saturated();
      //  Expect: "result" = 0000
      result = vqmovuns_s32(arg1);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      got = result;
      exp = 0;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2214() {

{
   {
      int64_t arg1;
      uint32_t result;
      char* str1 = "ReproInfo2 {semantics = \"saturating_narrow\", fnname = \"vqmovund_s64\", rettype = \"uint32_t\", argtypes = \"[int64_t]\", vals = [IntegerVal (-50557)], start_saturated = True}";
      int reported = 0;
      uint32_t got;
      uint32_t exp;
      arg1 = INT64_C(-50557);
      set_neon_saturated();
      //  Expect: "result" = 00000000
      result = vqmovund_s64(arg1);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      got = result;
      exp = 0;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIu32 " Got: %" PRIu32 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2215() {

{
   {
      uint8x8_t arg1;
      int16x8_t arg2;
      uint8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"saturating_narrow\", fnname = \"vqmovun_high_s16\", rettype = \"uint8x16_t\", argtypes = \"[uint8x8_t,int16x8_t]\", vals = [VectorVal [IntegerVal 0,IntegerVal 53,IntegerVal 127,IntegerVal 0,IntegerVal 255,IntegerVal 211,IntegerVal 255,IntegerVal 128],VectorVal [IntegerVal (-1),IntegerVal 14584,IntegerVal (-1),IntegerVal 0,IntegerVal (-32768),IntegerVal 0,IntegerVal (-32768),IntegerVal (-32768)]], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_u8(UINT64_C(0x80ffd3ff007f3500));
      arg2 = vcombine_s16(vcreate_s16(UINT64_C(0x0000ffff38f8ffff)),
                          vcreate_s16(UINT64_C(0x8000800000008000)));
      clear_neon_saturated();
      //  Expect: "result" = 000000000000ff0080ffd3ff007f3500
      result = vqmovun_high_s16(arg1, arg2);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 0);
         exp = UINT64_C(0x80ffd3ff007f3500);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 1);
         exp = UINT64_C(0x000000000000ff00);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2216() {

{
   {
      uint16x4_t arg1;
      int32x4_t arg2;
      uint16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"saturating_narrow\", fnname = \"vqmovun_high_s32\", rettype = \"uint16x8_t\", argtypes = \"[uint16x4_t,int32x4_t]\", vals = [VectorVal [IntegerVal 16464,IntegerVal 32767,IntegerVal 65535,IntegerVal 19975],VectorVal [IntegerVal (-32768),IntegerVal 2147418112,IntegerVal (-32769),IntegerVal 20718]], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_u16(UINT64_C(0x4e07ffff7fff4050));
      arg2 = vcombine_s32(vcreate_s32(UINT64_C(0x7fff0000ffff8000)),
                          vcreate_s32(UINT64_C(0x000050eeffff7fff)));
      clear_neon_saturated();
      //  Expect: "result" = 50ee0000ffff00004e07ffff7fff4050
      result = vqmovun_high_s32(arg1, arg2);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 0);
         exp = UINT64_C(0x4e07ffff7fff4050);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 1);
         exp = UINT64_C(0x50ee0000ffff0000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2217() {

{
   {
      uint32x2_t arg1;
      int64x2_t arg2;
      uint32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"saturating_narrow\", fnname = \"vqmovun_high_s64\", rettype = \"uint32x4_t\", argtypes = \"[uint32x2_t,int64x2_t]\", vals = [VectorVal [IntegerVal 2857140223,IntegerVal 4294967295],VectorVal [IntegerVal 9223090564025614335,IntegerVal 281472829227008]], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_u32(UINT64_C(0xffffffffaa4c7fff));
      arg2 = vcombine_s64(vcreate_s64(UINT64_C(0x7fff00008000ffff)),
                          vcreate_s64(UINT64_C(0x0000ffff80000000)));
      clear_neon_saturated();
      //  Expect: "result" = ffffffffffffffffffffffffaa4c7fff
      result = vqmovun_high_s64(arg1, arg2);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 0);
         exp = UINT64_C(0xffffffffaa4c7fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 1);
         exp = UINT64_C(0xffffffffffffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2218() {

{
   {
      uint8x16_t arg1;
      uint8x8_t arg2;
      uint8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"tbl\", fnname = \"vqtbl1_u8\", rettype = \"uint8x8_t\", argtypes = \"[uint8x16_t,uint8x8_t]\", vals = [VectorVal [IntegerVal 0,IntegerVal 128,IntegerVal 62,IntegerVal 128,IntegerVal 248,IntegerVal 0,IntegerVal 0,IntegerVal 127,IntegerVal 0,IntegerVal 255,IntegerVal 222,IntegerVal 186,IntegerVal 117,IntegerVal 255,IntegerVal 209,IntegerVal 156],VectorVal [IntegerVal 128,IntegerVal 255,IntegerVal 128,IntegerVal 0,IntegerVal 127,IntegerVal 127,IntegerVal 128,IntegerVal 255]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcombine_u8(vcreate_u8(UINT64_C(0x7f0000f8803e8000)),
                         vcreate_u8(UINT64_C(0x9cd1ff75badeff00)));
      arg2 = vcreate_u8(UINT64_C(0xff807f7f0080ff80));
      clear_neon_saturated();
      //  Expect: "result" = 0000000000000000
      result = vqtbl1_u8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u8(result), 0);
      exp = 0;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2219() {

{
   {
      uint8x16_t arg1;
      uint8x16_t arg2;
      uint8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"tbl\", fnname = \"vqtbl1q_u8\", rettype = \"uint8x16_t\", argtypes = \"[uint8x16_t,uint8x16_t]\", vals = [VectorVal [IntegerVal 38,IntegerVal 68,IntegerVal 127,IntegerVal 0,IntegerVal 127,IntegerVal 128,IntegerVal 103,IntegerVal 0,IntegerVal 0,IntegerVal 128,IntegerVal 128,IntegerVal 128,IntegerVal 255,IntegerVal 127,IntegerVal 255,IntegerVal 128],VectorVal [IntegerVal 134,IntegerVal 127,IntegerVal 255,IntegerVal 128,IntegerVal 128,IntegerVal 0,IntegerVal 255,IntegerVal 48,IntegerVal 128,IntegerVal 127,IntegerVal 127,IntegerVal 0,IntegerVal 255,IntegerVal 45,IntegerVal 130,IntegerVal 0]], start_saturated = True}";
      int reported = 0;
      arg1 = vcombine_u8(vcreate_u8(UINT64_C(0x0067807f007f4426)),
                         vcreate_u8(UINT64_C(0x80ff7fff80808000)));
      arg2 = vcombine_u8(vcreate_u8(UINT64_C(0x30ff008080ff7f86)),
                         vcreate_u8(UINT64_C(0x00822dff007f7f80)));
      set_neon_saturated();
      //  Expect: "result" = 26000000260000000000260000000000
      result = vqtbl1q_u8(arg1, arg2);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 0);
         exp = UINT64_C(0x0000260000000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 1);
         exp = UINT64_C(0x2600000026000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2220() {

{
   {
      int8x16_t arg1;
      uint8x8_t arg2;
      int8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"tbl\", fnname = \"vqtbl1_s8\", rettype = \"int8x8_t\", argtypes = \"[int8x16_t,uint8x8_t]\", vals = [VectorVal [IntegerVal 127,IntegerVal (-1),IntegerVal (-41),IntegerVal (-128),IntegerVal (-128),IntegerVal (-1),IntegerVal (-1),IntegerVal 127,IntegerVal (-114),IntegerVal (-10),IntegerVal 36,IntegerVal (-29),IntegerVal (-1),IntegerVal 0,IntegerVal (-128),IntegerVal (-128)],VectorVal [IntegerVal 127,IntegerVal 0,IntegerVal 110,IntegerVal 255,IntegerVal 255,IntegerVal 0,IntegerVal 81,IntegerVal 37]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcombine_s8(vcreate_s8(UINT64_C(0x7fffff8080d7ff7f)),
                         vcreate_s8(UINT64_C(0x808000ffe324f68e)));
      arg2 = vcreate_u8(UINT64_C(0x255100ffff6e007f));
      clear_neon_saturated();
      //  Expect: "result" = 00007f0000007f00
      result = vqtbl1_s8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s8(result), 0);
      exp = UINT64_C(0x00007f0000007f00);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2221() {

{
   {
      int8x16_t arg1;
      uint8x16_t arg2;
      int8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"tbl\", fnname = \"vqtbl1q_s8\", rettype = \"int8x16_t\", argtypes = \"[int8x16_t,uint8x16_t]\", vals = [VectorVal [IntegerVal 120,IntegerVal (-1),IntegerVal (-1),IntegerVal (-128),IntegerVal (-84),IntegerVal 0,IntegerVal 127,IntegerVal (-1),IntegerVal 0,IntegerVal (-1),IntegerVal 0,IntegerVal (-128),IntegerVal (-78),IntegerVal 0,IntegerVal (-1),IntegerVal (-1)],VectorVal [IntegerVal 128,IntegerVal 196,IntegerVal 233,IntegerVal 0,IntegerVal 255,IntegerVal 127,IntegerVal 248,IntegerVal 255,IntegerVal 128,IntegerVal 127,IntegerVal 54,IntegerVal 127,IntegerVal 128,IntegerVal 128,IntegerVal 127,IntegerVal 128]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s8(vcreate_s8(UINT64_C(0xff7f00ac80ffff78)),
                         vcreate_s8(UINT64_C(0xffff00b28000ff00)));
      arg2 = vcombine_u8(vcreate_u8(UINT64_C(0xfff87fff00e9c480)),
                         vcreate_u8(UINT64_C(0x807f80807f367f80)));
      clear_neon_saturated();
      //  Expect: "result" = 00000000000000000000000078000000
      result = vqtbl1q_s8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result), 0);
         exp = UINT64_C(0x0000000078000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result), 1);
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2222() {

{
   {
      poly8x16_t arg1;
      uint8x8_t arg2;
      poly8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"tbl\", fnname = \"vqtbl1_p8\", rettype = \"poly8x8_t\", argtypes = \"[poly8x16_t,uint8x8_t]\", vals = [VectorVal [PolyVal [0,0,0,1,1,0,0,1],PolyVal [1,0,1,1,1,1,1,1],PolyVal [0,0,1,1,0,0,0,0],PolyVal [0,1,0,1,1,1,0,1],PolyVal [1,0,1,0,0,1,0,1],PolyVal [0,0,0,1,1,1,1,0],PolyVal [1,0,0,1,1,1,0,1],PolyVal [1,0,0,0,1,0,1,1],PolyVal [1,1,1,0,1,1,1,0],PolyVal [0,0,0,1,0,0,1,1],PolyVal [1,0,0,0,0,0,1,0],PolyVal [1,1,1,1,1,0,0,0],PolyVal [0,1,1,1,0,1,1,0],PolyVal [0,0,1,0,0,0,0,1],PolyVal [0,0,1,1,1,0,0,1],PolyVal [1,1,0,1,1,0,0,1]],VectorVal [IntegerVal 128,IntegerVal 128,IntegerVal 0,IntegerVal 127,IntegerVal 0,IntegerVal 215,IntegerVal 127,IntegerVal 128]], start_saturated = True}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcombine_p8(vcreate_p8(UINT64_C(0xd1b978a5ba0cfd98)),
                         vcreate_p8(UINT64_C(0x9b9c846e1f41c877)));
      arg2 = vcreate_u8(UINT64_C(0x807fd7007f008080));
      set_neon_saturated();
      //  Expect: "result" = 0000009800980000
      result = vqtbl1_p8(arg1, arg2);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_p8(result), 0);
      exp = UINT64_C(0x0000009800980000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2223() {

{
   {
      poly8x16_t arg1;
      uint8x16_t arg2;
      poly8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"tbl\", fnname = \"vqtbl1q_p8\", rettype = \"poly8x16_t\", argtypes = \"[poly8x16_t,uint8x16_t]\", vals = [VectorVal [PolyVal [0,1,1,1,0,0,1,0],PolyVal [1,0,0,0,0,1,1,0],PolyVal [0,1,1,1,1,1,1,1],PolyVal [0,1,0,0,1,0,1,1],PolyVal [1,1,1,0,0,0,0,0],PolyVal [0,1,0,1,1,0,1,0],PolyVal [0,1,1,0,0,0,0,0],PolyVal [0,1,0,1,0,0,1,0],PolyVal [1,0,0,0,0,0,1,0],PolyVal [1,1,0,0,0,0,0,1],PolyVal [1,0,0,0,1,0,0,1],PolyVal [1,1,0,1,1,1,0,1],PolyVal [1,1,1,0,1,1,1,1],PolyVal [0,0,0,1,0,1,0,1],PolyVal [1,1,1,0,1,0,1,1],PolyVal [0,0,0,0,0,0,0,0]],VectorVal [IntegerVal 128,IntegerVal 127,IntegerVal 255,IntegerVal 150,IntegerVal 246,IntegerVal 255,IntegerVal 255,IntegerVal 127,IntegerVal 127,IntegerVal 255,IntegerVal 255,IntegerVal 128,IntegerVal 255,IntegerVal 255,IntegerVal 255,IntegerVal 127]], start_saturated = True}";
      int reported = 0;
      arg1 = vcombine_p8(vcreate_p8(UINT64_C(0x4a065a07d2fe614e)),
                         vcreate_p8(UINT64_C(0x00d7a8f7bb918341)));
      arg2 = vcombine_u8(vcreate_u8(UINT64_C(0x7ffffff696ff7f80)),
                         vcreate_u8(UINT64_C(0x7fffffff80ffff7f)));
      set_neon_saturated();
      //  Expect: "result" = 00000000000000000000000000000000
      result = vqtbl1q_p8(arg1, arg2);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p8(result), 0);
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p8(result), 1);
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2224() {

{
   {
      uint8x16x2_t arg1;
      uint8x8_t arg2;
      uint8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"tbl\", fnname = \"vqtbl2_u8\", rettype = \"uint8x8_t\", argtypes = \"[uint8x16x2_t,uint8x8_t]\", vals = [ArrayVal [VectorVal [IntegerVal 54,IntegerVal 255,IntegerVal 255,IntegerVal 128,IntegerVal 0,IntegerVal 128,IntegerVal 128,IntegerVal 127,IntegerVal 250,IntegerVal 128,IntegerVal 39,IntegerVal 127,IntegerVal 255,IntegerVal 128,IntegerVal 70,IntegerVal 255],VectorVal [IntegerVal 170,IntegerVal 15,IntegerVal 127,IntegerVal 127,IntegerVal 127,IntegerVal 128,IntegerVal 255,IntegerVal 0,IntegerVal 0,IntegerVal 255,IntegerVal 128,IntegerVal 127,IntegerVal 16,IntegerVal 127,IntegerVal 164,IntegerVal 1]],VectorVal [IntegerVal 255,IntegerVal 186,IntegerVal 127,IntegerVal 255,IntegerVal 0,IntegerVal 128,IntegerVal 174,IntegerVal 127]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1.val[0] = vcombine_u8(vcreate_u8(UINT64_C(0x7f80800080ffff36)),
                                vcreate_u8(UINT64_C(0xff4680ff7f2780fa)));
      arg1.val[1] = vcombine_u8(vcreate_u8(UINT64_C(0x00ff807f7f7f0faa)),
                                vcreate_u8(UINT64_C(0x01a47f107f80ff00)));
      arg2 = vcreate_u8(UINT64_C(0x7fae8000ff7fbaff));
      clear_neon_saturated();
      //  Expect: "result" = 0000003600000000
      result = vqtbl2_u8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u8(result), 0);
      exp = UINT64_C(0x0000003600000000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2225() {

{
   {
      uint8x16x2_t arg1;
      uint8x16_t arg2;
      uint8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"tbl\", fnname = \"vqtbl2q_u8\", rettype = \"uint8x16_t\", argtypes = \"[uint8x16x2_t,uint8x16_t]\", vals = [ArrayVal [VectorVal [IntegerVal 255,IntegerVal 128,IntegerVal 127,IntegerVal 127,IntegerVal 242,IntegerVal 0,IntegerVal 255,IntegerVal 51,IntegerVal 255,IntegerVal 128,IntegerVal 255,IntegerVal 235,IntegerVal 127,IntegerVal 0,IntegerVal 253,IntegerVal 127],VectorVal [IntegerVal 0,IntegerVal 0,IntegerVal 142,IntegerVal 255,IntegerVal 255,IntegerVal 255,IntegerVal 128,IntegerVal 255,IntegerVal 0,IntegerVal 128,IntegerVal 128,IntegerVal 255,IntegerVal 0,IntegerVal 255,IntegerVal 255,IntegerVal 255]],VectorVal [IntegerVal 0,IntegerVal 0,IntegerVal 21,IntegerVal 128,IntegerVal 128,IntegerVal 0,IntegerVal 128,IntegerVal 10,IntegerVal 0,IntegerVal 8,IntegerVal 184,IntegerVal 0,IntegerVal 255,IntegerVal 255,IntegerVal 128,IntegerVal 0]], start_saturated = False}";
      int reported = 0;
      arg1.val[0] = vcombine_u8(vcreate_u8(UINT64_C(0x33ff00f27f7f80ff)),
                                vcreate_u8(UINT64_C(0x7ffd007febff80ff)));
      arg1.val[1] = vcombine_u8(vcreate_u8(UINT64_C(0xff80ffffff8e0000)),
                                vcreate_u8(UINT64_C(0xffffff00ff808000)));
      arg2 = vcombine_u8(vcreate_u8(UINT64_C(0x0a80008080150000)),
                         vcreate_u8(UINT64_C(0x0080ffff00b80800)));
      clear_neon_saturated();
      //  Expect: "result" = ff000000ff00ffffff00ff0000ffffff
      result = vqtbl2q_u8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 0);
         exp = UINT64_C(0xff00ff0000ffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 1);
         exp = UINT64_C(0xff000000ff00ffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2226() {

{
   {
      int8x16x2_t arg1;
      uint8x8_t arg2;
      int8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"tbl\", fnname = \"vqtbl2_s8\", rettype = \"int8x8_t\", argtypes = \"[int8x16x2_t,uint8x8_t]\", vals = [ArrayVal [VectorVal [IntegerVal 127,IntegerVal 0,IntegerVal (-1),IntegerVal 0,IntegerVal (-128),IntegerVal (-128),IntegerVal 0,IntegerVal (-128),IntegerVal 0,IntegerVal 127,IntegerVal 127,IntegerVal (-128),IntegerVal 84,IntegerVal (-107),IntegerVal (-1),IntegerVal 0],VectorVal [IntegerVal 96,IntegerVal 0,IntegerVal (-1),IntegerVal (-93),IntegerVal (-128),IntegerVal 127,IntegerVal (-128),IntegerVal 127,IntegerVal 0,IntegerVal 127,IntegerVal 127,IntegerVal (-128),IntegerVal (-1),IntegerVal 127,IntegerVal 94,IntegerVal (-1)]],VectorVal [IntegerVal 255,IntegerVal 127,IntegerVal 127,IntegerVal 127,IntegerVal 128,IntegerVal 107,IntegerVal 3,IntegerVal 128]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1.val[0] = vcombine_s8(vcreate_s8(UINT64_C(0x8000808000ff007f)),
                                vcreate_s8(UINT64_C(0x00ff9554807f7f00)));
      arg1.val[1] = vcombine_s8(vcreate_s8(UINT64_C(0x7f807f80a3ff0060)),
                                vcreate_s8(UINT64_C(0xff5e7fff807f7f00)));
      arg2 = vcreate_u8(UINT64_C(0x80036b807f7f7fff));
      clear_neon_saturated();
      //  Expect: "result" = 0000000000000000
      result = vqtbl2_s8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s8(result), 0);
      exp = 0;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2227() {

{
   {
      int8x16x2_t arg1;
      uint8x16_t arg2;
      int8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"tbl\", fnname = \"vqtbl2q_s8\", rettype = \"int8x16_t\", argtypes = \"[int8x16x2_t,uint8x16_t]\", vals = [ArrayVal [VectorVal [IntegerVal (-1),IntegerVal (-10),IntegerVal 16,IntegerVal 0,IntegerVal 127,IntegerVal (-12),IntegerVal 127,IntegerVal 0,IntegerVal 0,IntegerVal 0,IntegerVal (-1),IntegerVal (-128),IntegerVal (-128),IntegerVal (-100),IntegerVal (-16),IntegerVal 0],VectorVal [IntegerVal (-1),IntegerVal 95,IntegerVal (-102),IntegerVal 0,IntegerVal (-82),IntegerVal 127,IntegerVal 0,IntegerVal 99,IntegerVal 127,IntegerVal (-128),IntegerVal 0,IntegerVal 0,IntegerVal 59,IntegerVal 127,IntegerVal 127,IntegerVal 0]],VectorVal [IntegerVal 255,IntegerVal 255,IntegerVal 98,IntegerVal 128,IntegerVal 255,IntegerVal 255,IntegerVal 128,IntegerVal 255,IntegerVal 128,IntegerVal 127,IntegerVal 128,IntegerVal 72,IntegerVal 127,IntegerVal 127,IntegerVal 128,IntegerVal 127]], start_saturated = False}";
      int reported = 0;
      arg1.val[0] = vcombine_s8(vcreate_s8(UINT64_C(0x007ff47f0010f6ff)),
                                vcreate_s8(UINT64_C(0x00f09c8080ff0000)));
      arg1.val[1] = vcombine_s8(vcreate_s8(UINT64_C(0x63007fae009a5fff)),
                                vcreate_s8(UINT64_C(0x007f7f3b0000807f)));
      arg2 = vcombine_u8(vcreate_u8(UINT64_C(0xff80ffff8062ffff)),
                         vcreate_u8(UINT64_C(0x7f807f7f48807f80)));
      clear_neon_saturated();
      //  Expect: "result" = 00000000000000000000000000000000
      result = vqtbl2q_s8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result), 0);
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result), 1);
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2228() {

{
   {
      poly8x16x2_t arg1;
      uint8x8_t arg2;
      poly8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"tbl\", fnname = \"vqtbl2_p8\", rettype = \"poly8x8_t\", argtypes = \"[poly8x16x2_t,uint8x8_t]\", vals = [ArrayVal [VectorVal [PolyVal [0,1,1,1,1,1,0,0],PolyVal [0,0,0,0,1,0,1,1],PolyVal [0,1,1,1,1,0,1,0],PolyVal [0,0,0,1,1,0,1,1],PolyVal [0,0,0,0,1,1,0,0],PolyVal [0,0,1,1,1,1,0,0],PolyVal [0,1,0,0,0,0,0,0],PolyVal [0,1,0,0,1,0,1,0],PolyVal [1,0,0,0,1,0,0,0],PolyVal [0,0,0,1,0,0,0,0],PolyVal [1,1,0,1,1,0,1,0],PolyVal [0,0,0,0,0,1,0,1],PolyVal [1,0,1,1,0,1,1,0],PolyVal [0,1,0,0,0,1,0,1],PolyVal [1,1,0,0,0,1,0,0],PolyVal [0,1,0,0,1,0,0,1]],VectorVal [PolyVal [0,0,0,0,1,0,0,1],PolyVal [1,0,1,1,1,0,0,1],PolyVal [1,0,1,1,0,0,1,1],PolyVal [0,0,1,1,1,0,1,1],PolyVal [1,0,0,0,0,0,1,1],PolyVal [0,1,1,0,0,0,1,0],PolyVal [0,0,1,0,0,0,0,0],PolyVal [0,0,0,0,1,0,1,0],PolyVal [1,0,1,1,0,1,0,1],PolyVal [0,0,1,1,0,1,0,1],PolyVal [1,1,0,1,0,1,1,0],PolyVal [0,1,0,0,0,1,0,0],PolyVal [0,1,1,1,0,0,1,1],PolyVal [1,1,0,0,1,1,0,1],PolyVal [1,1,0,0,0,0,1,0],PolyVal [1,0,1,0,1,0,1,1]]],VectorVal [IntegerVal 147,IntegerVal 127,IntegerVal 128,IntegerVal 128,IntegerVal 128,IntegerVal 128,IntegerVal 208,IntegerVal 127]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1.val[0] = vcombine_p8(vcreate_p8(UINT64_C(0x52023c30d85ed03e)),
                                vcreate_p8(UINT64_C(0x9223a26da05b0811)));
      arg1.val[1] = vcombine_p8(vcreate_p8(UINT64_C(0x500446c1dccd9d90)),
                                vcreate_p8(UINT64_C(0xd543b3ce226bacad)));
      arg2 = vcreate_u8(UINT64_C(0x7fd0808080807f93));
      clear_neon_saturated();
      //  Expect: "result" = 0000000000000000
      result = vqtbl2_p8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_p8(result), 0);
      exp = 0;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2229() {

{
   {
      poly8x16x2_t arg1;
      uint8x16_t arg2;
      poly8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"tbl\", fnname = \"vqtbl2q_p8\", rettype = \"poly8x16_t\", argtypes = \"[poly8x16x2_t,uint8x16_t]\", vals = [ArrayVal [VectorVal [PolyVal [0,1,0,0,0,1,1,0],PolyVal [1,1,0,0,0,0,0,1],PolyVal [0,0,1,1,0,1,1,0],PolyVal [0,1,0,1,1,0,0,0],PolyVal [0,0,1,1,1,1,0,1],PolyVal [0,1,0,0,0,0,1,1],PolyVal [1,0,1,0,1,0,0,0],PolyVal [0,1,0,0,1,1,1,0],PolyVal [0,1,0,1,0,1,1,0],PolyVal [0,1,0,0,0,0,1,0],PolyVal [1,0,0,1,0,0,1,1],PolyVal [1,1,0,1,1,1,1,0],PolyVal [1,0,1,1,1,0,1,1],PolyVal [0,0,0,0,1,1,1,0],PolyVal [0,1,0,1,1,0,1,0],PolyVal [1,1,1,1,0,1,1,1]],VectorVal [PolyVal [1,0,0,1,0,0,1,1],PolyVal [0,1,1,1,1,1,1,1],PolyVal [0,1,0,1,0,0,1,0],PolyVal [1,0,1,0,0,0,0,0],PolyVal [1,0,1,0,0,1,0,0],PolyVal [1,1,1,1,0,1,0,1],PolyVal [1,0,1,1,1,1,1,1],PolyVal [1,1,0,1,0,1,0,1],PolyVal [1,0,1,0,0,1,0,0],PolyVal [0,1,0,0,0,1,1,0],PolyVal [1,0,0,1,0,1,0,1],PolyVal [1,1,1,1,1,1,0,1],PolyVal [0,1,1,0,1,0,1,1],PolyVal [1,1,1,1,0,1,0,0],PolyVal [0,0,0,0,1,0,1,1],PolyVal [0,0,0,1,0,0,0,1]]],VectorVal [IntegerVal 255,IntegerVal 255,IntegerVal 127,IntegerVal 0,IntegerVal 127,IntegerVal 255,IntegerVal 128,IntegerVal 127,IntegerVal 127,IntegerVal 0,IntegerVal 127,IntegerVal 157,IntegerVal 39,IntegerVal 237,IntegerVal 127,IntegerVal 0]], start_saturated = False}";
      int reported = 0;
      arg1.val[0] = vcombine_p8(vcreate_p8(UINT64_C(0x7215c2bc1a6c8362)),
                                vcreate_p8(UINT64_C(0xef5a70dd7bc9426a)));
      arg1.val[1] = vcombine_p8(vcreate_p8(UINT64_C(0xabfdaf25054afec9)),
                                vcreate_p8(UINT64_C(0x88d02fd6bfa96225)));
      arg2 = vcombine_u8(vcreate_u8(UINT64_C(0x7f80ff7f007fffff)),
                         vcreate_u8(UINT64_C(0x007fed279d7f007f)));
      clear_neon_saturated();
      //  Expect: "result" = 62000000000062000000000062000000
      result = vqtbl2q_p8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p8(result), 0);
         exp = UINT64_C(0x0000000062000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p8(result), 1);
         exp = UINT64_C(0x6200000000006200);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2230() {

{
   {
      uint8x16x3_t arg1;
      uint8x8_t arg2;
      uint8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"tbl\", fnname = \"vqtbl3_u8\", rettype = \"uint8x8_t\", argtypes = \"[uint8x16x3_t,uint8x8_t]\", vals = [ArrayVal [VectorVal [IntegerVal 255,IntegerVal 127,IntegerVal 0,IntegerVal 127,IntegerVal 0,IntegerVal 127,IntegerVal 112,IntegerVal 127,IntegerVal 128,IntegerVal 127,IntegerVal 0,IntegerVal 0,IntegerVal 128,IntegerVal 133,IntegerVal 255,IntegerVal 127],VectorVal [IntegerVal 127,IntegerVal 0,IntegerVal 255,IntegerVal 253,IntegerVal 128,IntegerVal 127,IntegerVal 97,IntegerVal 128,IntegerVal 127,IntegerVal 0,IntegerVal 127,IntegerVal 128,IntegerVal 255,IntegerVal 0,IntegerVal 0,IntegerVal 128],VectorVal [IntegerVal 127,IntegerVal 127,IntegerVal 154,IntegerVal 255,IntegerVal 128,IntegerVal 255,IntegerVal 128,IntegerVal 255,IntegerVal 128,IntegerVal 0,IntegerVal 106,IntegerVal 127,IntegerVal 255,IntegerVal 255,IntegerVal 127,IntegerVal 255]],VectorVal [IntegerVal 128,IntegerVal 255,IntegerVal 255,IntegerVal 127,IntegerVal 119,IntegerVal 0,IntegerVal 151,IntegerVal 128]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1.val[0] = vcombine_u8(vcreate_u8(UINT64_C(0x7f707f007f007fff)),
                                vcreate_u8(UINT64_C(0x7fff858000007f80)));
      arg1.val[1] = vcombine_u8(vcreate_u8(UINT64_C(0x80617f80fdff007f)),
                                vcreate_u8(UINT64_C(0x800000ff807f007f)));
      arg1.val[2] = vcombine_u8(vcreate_u8(UINT64_C(0xff80ff80ff9a7f7f)),
                                vcreate_u8(UINT64_C(0xff7fffff7f6a0080)));
      arg2 = vcreate_u8(UINT64_C(0x809700777fffff80));
      clear_neon_saturated();
      //  Expect: "result" = 0000ff0000000000
      result = vqtbl3_u8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u8(result), 0);
      exp = UINT64_C(0x0000ff0000000000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2231() {

{
   {
      uint8x16x3_t arg1;
      uint8x16_t arg2;
      uint8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"tbl\", fnname = \"vqtbl3q_u8\", rettype = \"uint8x16_t\", argtypes = \"[uint8x16x3_t,uint8x16_t]\", vals = [ArrayVal [VectorVal [IntegerVal 128,IntegerVal 128,IntegerVal 131,IntegerVal 128,IntegerVal 127,IntegerVal 61,IntegerVal 255,IntegerVal 239,IntegerVal 255,IntegerVal 128,IntegerVal 255,IntegerVal 255,IntegerVal 127,IntegerVal 0,IntegerVal 255,IntegerVal 255],VectorVal [IntegerVal 255,IntegerVal 127,IntegerVal 40,IntegerVal 0,IntegerVal 127,IntegerVal 0,IntegerVal 128,IntegerVal 127,IntegerVal 255,IntegerVal 128,IntegerVal 0,IntegerVal 14,IntegerVal 255,IntegerVal 127,IntegerVal 0,IntegerVal 255],VectorVal [IntegerVal 255,IntegerVal 0,IntegerVal 128,IntegerVal 255,IntegerVal 127,IntegerVal 255,IntegerVal 0,IntegerVal 86,IntegerVal 216,IntegerVal 255,IntegerVal 255,IntegerVal 128,IntegerVal 127,IntegerVal 169,IntegerVal 0,IntegerVal 128]],VectorVal [IntegerVal 255,IntegerVal 127,IntegerVal 127,IntegerVal 56,IntegerVal 255,IntegerVal 128,IntegerVal 255,IntegerVal 128,IntegerVal 138,IntegerVal 221,IntegerVal 255,IntegerVal 127,IntegerVal 128,IntegerVal 0,IntegerVal 127,IntegerVal 128]], start_saturated = False}";
      int reported = 0;
      arg1.val[0] = vcombine_u8(vcreate_u8(UINT64_C(0xefff3d7f80838080)),
                                vcreate_u8(UINT64_C(0xffff007fffff80ff)));
      arg1.val[1] = vcombine_u8(vcreate_u8(UINT64_C(0x7f80007f00287fff)),
                                vcreate_u8(UINT64_C(0xff007fff0e0080ff)));
      arg1.val[2] = vcombine_u8(vcreate_u8(UINT64_C(0x5600ff7fff8000ff)),
                                vcreate_u8(UINT64_C(0x8000a97f80ffffd8)));
      arg2 = vcombine_u8(vcreate_u8(UINT64_C(0x80ff80ff387f7fff)),
                         vcreate_u8(UINT64_C(0x807f00807fffdd8a)));
      clear_neon_saturated();
      //  Expect: "result" = 00008000000000000000000000000000
      result = vqtbl3q_u8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 0);
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 1);
         exp = UINT64_C(0x0000800000000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2232() {

{
   {
      int8x16x3_t arg1;
      uint8x8_t arg2;
      int8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"tbl\", fnname = \"vqtbl3_s8\", rettype = \"int8x8_t\", argtypes = \"[int8x16x3_t,uint8x8_t]\", vals = [ArrayVal [VectorVal [IntegerVal (-128),IntegerVal 0,IntegerVal 36,IntegerVal (-128),IntegerVal (-1),IntegerVal 108,IntegerVal (-1),IntegerVal (-128),IntegerVal (-1),IntegerVal (-128),IntegerVal (-101),IntegerVal 127,IntegerVal 127,IntegerVal (-1),IntegerVal 86,IntegerVal (-1)],VectorVal [IntegerVal (-128),IntegerVal 0,IntegerVal 127,IntegerVal 0,IntegerVal 83,IntegerVal (-1),IntegerVal 127,IntegerVal (-1),IntegerVal (-128),IntegerVal 127,IntegerVal 0,IntegerVal 0,IntegerVal 0,IntegerVal 111,IntegerVal 119,IntegerVal 0],VectorVal [IntegerVal 127,IntegerVal (-1),IntegerVal (-10),IntegerVal (-77),IntegerVal 0,IntegerVal (-105),IntegerVal 0,IntegerVal (-128),IntegerVal 0,IntegerVal (-1),IntegerVal 0,IntegerVal (-1),IntegerVal 91,IntegerVal 0,IntegerVal (-1),IntegerVal (-128)]],VectorVal [IntegerVal 0,IntegerVal 255,IntegerVal 35,IntegerVal 199,IntegerVal 0,IntegerVal 127,IntegerVal 58,IntegerVal 128]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1.val[0] = vcombine_s8(vcreate_s8(UINT64_C(0x80ff6cff80240080)),
                                vcreate_s8(UINT64_C(0xff56ff7f7f9b80ff)));
      arg1.val[1] = vcombine_s8(vcreate_s8(UINT64_C(0xff7fff53007f0080)),
                                vcreate_s8(UINT64_C(0x00776f0000007f80)));
      arg1.val[2] = vcombine_s8(vcreate_s8(UINT64_C(0x80009700b3f6ff7f)),
                                vcreate_s8(UINT64_C(0x80ff005bff00ff00)));
      arg2 = vcreate_u8(UINT64_C(0x803a7f00c723ff00));
      clear_neon_saturated();
      //  Expect: "result" = 0000008000b30080
      result = vqtbl3_s8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s8(result), 0);
      exp = UINT64_C(0x0000008000b30080);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2233() {

{
   {
      int8x16x3_t arg1;
      uint8x16_t arg2;
      int8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"tbl\", fnname = \"vqtbl3q_s8\", rettype = \"int8x16_t\", argtypes = \"[int8x16x3_t,uint8x16_t]\", vals = [ArrayVal [VectorVal [IntegerVal 0,IntegerVal 0,IntegerVal (-128),IntegerVal 127,IntegerVal 50,IntegerVal (-1),IntegerVal 0,IntegerVal (-128),IntegerVal 0,IntegerVal (-1),IntegerVal 0,IntegerVal (-103),IntegerVal (-128),IntegerVal 0,IntegerVal 0,IntegerVal (-128)],VectorVal [IntegerVal (-1),IntegerVal (-128),IntegerVal 0,IntegerVal 127,IntegerVal 0,IntegerVal (-128),IntegerVal (-1),IntegerVal (-80),IntegerVal (-1),IntegerVal (-1),IntegerVal (-1),IntegerVal 127,IntegerVal 0,IntegerVal (-1),IntegerVal (-128),IntegerVal (-4)],VectorVal [IntegerVal (-128),IntegerVal (-128),IntegerVal (-1),IntegerVal (-69),IntegerVal (-128),IntegerVal (-91),IntegerVal 26,IntegerVal 0,IntegerVal 0,IntegerVal 54,IntegerVal 0,IntegerVal (-1),IntegerVal 127,IntegerVal 127,IntegerVal 127,IntegerVal 127]],VectorVal [IntegerVal 128,IntegerVal 128,IntegerVal 127,IntegerVal 0,IntegerVal 255,IntegerVal 255,IntegerVal 128,IntegerVal 0,IntegerVal 0,IntegerVal 19,IntegerVal 128,IntegerVal 179,IntegerVal 127,IntegerVal 255,IntegerVal 0,IntegerVal 9]], start_saturated = False}";
      int reported = 0;
      arg1.val[0] = vcombine_s8(vcreate_s8(UINT64_C(0x8000ff327f800000)),
                                vcreate_s8(UINT64_C(0x800000809900ff00)));
      arg1.val[1] = vcombine_s8(vcreate_s8(UINT64_C(0xb0ff80007f0080ff)),
                                vcreate_s8(UINT64_C(0xfc80ff007fffffff)));
      arg1.val[2] = vcombine_s8(vcreate_s8(UINT64_C(0x001aa580bbff8080)),
                                vcreate_s8(UINT64_C(0x7f7f7f7fff003600)));
      arg2 = vcombine_u8(vcreate_u8(UINT64_C(0x0080ffff007f8080)),
                         vcreate_u8(UINT64_C(0x0900ff7fb3801300)));
      clear_neon_saturated();
      //  Expect: "result" = ff00000000007f000000000000000000
      result = vqtbl3q_s8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result), 0);
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result), 1);
         exp = UINT64_C(0xff00000000007f00);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2234() {

{
   {
      poly8x16x3_t arg1;
      uint8x8_t arg2;
      poly8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"tbl\", fnname = \"vqtbl3_p8\", rettype = \"poly8x8_t\", argtypes = \"[poly8x16x3_t,uint8x8_t]\", vals = [ArrayVal [VectorVal [PolyVal [1,0,0,0,1,0,1,0],PolyVal [0,0,1,0,0,1,1,0],PolyVal [1,1,1,0,0,1,0,0],PolyVal [1,0,0,1,0,1,1,1],PolyVal [1,0,0,0,0,0,0,0],PolyVal [1,1,1,0,0,1,1,1],PolyVal [0,1,1,0,0,0,1,1],PolyVal [0,1,0,1,1,1,1,1],PolyVal [0,0,1,1,0,0,1,1],PolyVal [0,0,1,1,1,0,1,1],PolyVal [0,1,1,1,0,1,1,1],PolyVal [0,1,1,0,1,1,0,0],PolyVal [1,1,1,0,0,0,0,1],PolyVal [0,1,0,0,0,1,1,0],PolyVal [0,0,0,1,1,0,1,0],PolyVal [0,0,0,0,1,0,0,0]],VectorVal [PolyVal [1,1,1,1,1,0,1,0],PolyVal [1,1,1,1,1,1,1,1],PolyVal [0,1,0,0,1,0,0,1],PolyVal [0,1,0,1,1,0,0,1],PolyVal [0,1,0,0,0,0,0,1],PolyVal [0,1,1,0,0,0,0,1],PolyVal [1,0,0,1,0,1,1,0],PolyVal [1,0,1,0,0,1,0,1],PolyVal [1,1,1,0,1,1,0,1],PolyVal [0,1,1,1,1,0,0,0],PolyVal [1,0,0,0,1,0,0,1],PolyVal [1,0,0,1,0,1,0,0],PolyVal [0,1,0,0,1,1,1,1],PolyVal [1,1,1,0,1,1,0,1],PolyVal [1,0,0,1,0,0,1,0],PolyVal [0,1,0,1,0,0,0,0]],VectorVal [PolyVal [0,1,0,1,0,1,0,1],PolyVal [1,0,1,1,1,1,0,0],PolyVal [1,0,0,1,1,1,1,0],PolyVal [0,0,1,1,1,1,1,0],PolyVal [0,1,1,0,0,0,1,0],PolyVal [1,0,0,1,1,1,0,0],PolyVal [0,1,0,0,1,0,0,0],PolyVal [1,1,0,1,0,0,0,1],PolyVal [0,0,1,0,0,1,1,0],PolyVal [0,0,1,0,1,1,0,0],PolyVal [0,1,1,1,0,1,0,1],PolyVal [1,0,1,0,0,0,0,1],PolyVal [0,1,1,1,0,0,1,0],PolyVal [1,1,0,1,1,1,0,1],PolyVal [1,0,1,1,0,0,1,0],PolyVal [0,0,1,0,1,1,0,0]]],VectorVal [IntegerVal 127,IntegerVal 255,IntegerVal 255,IntegerVal 255,IntegerVal 127,IntegerVal 255,IntegerVal 255,IntegerVal 127]], start_saturated = True}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1.val[0] = vcombine_p8(vcreate_p8(UINT64_C(0xfac6e701e9276451)),
                                vcreate_p8(UINT64_C(0x1058628736eedccc)));
      arg1.val[1] = vcombine_p8(vcreate_p8(UINT64_C(0xa56986829a92ff5f)),
                                vcreate_p8(UINT64_C(0x0a49b7f229911eb7)));
      arg1.val[2] = vcombine_p8(vcreate_p8(UINT64_C(0x8b1239467c793daa)),
                                vcreate_p8(UINT64_C(0x344dbb4e85ae3464)));
      arg2 = vcreate_u8(UINT64_C(0x7fffff7fffffff7f));
      set_neon_saturated();
      //  Expect: "result" = 0000000000000000
      result = vqtbl3_p8(arg1, arg2);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_p8(result), 0);
      exp = 0;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2235() {

{
   {
      poly8x16x3_t arg1;
      uint8x16_t arg2;
      poly8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"tbl\", fnname = \"vqtbl3q_p8\", rettype = \"poly8x16_t\", argtypes = \"[poly8x16x3_t,uint8x16_t]\", vals = [ArrayVal [VectorVal [PolyVal [1,0,0,0,0,0,0,0],PolyVal [0,1,0,0,0,0,1,0],PolyVal [0,1,0,1,0,0,1,1],PolyVal [0,1,1,0,1,0,0,0],PolyVal [1,0,0,0,1,1,1,0],PolyVal [1,0,0,1,0,0,1,1],PolyVal [0,1,0,1,0,0,1,0],PolyVal [1,1,1,0,1,0,0,1],PolyVal [1,1,0,1,0,0,1,1],PolyVal [0,0,0,1,0,0,1,0],PolyVal [0,1,0,1,1,0,1,1],PolyVal [0,0,1,1,1,0,0,0],PolyVal [0,0,1,0,1,0,0,1],PolyVal [1,0,0,0,1,0,1,0],PolyVal [1,0,0,1,0,0,1,0],PolyVal [1,0,0,0,0,0,0,1]],VectorVal [PolyVal [0,0,1,1,0,1,1,1],PolyVal [1,0,1,1,1,1,0,1],PolyVal [1,0,1,1,0,0,0,1],PolyVal [1,1,0,1,1,0,0,0],PolyVal [0,1,0,0,0,0,0,0],PolyVal [1,1,0,1,0,1,1,1],PolyVal [0,1,0,0,1,1,1,0],PolyVal [0,0,1,1,0,1,0,1],PolyVal [1,0,0,1,0,1,0,1],PolyVal [1,0,1,1,1,0,0,1],PolyVal [1,1,0,0,1,0,1,1],PolyVal [0,1,1,0,1,0,1,0],PolyVal [0,0,0,0,0,1,0,1],PolyVal [0,1,1,1,1,0,1,0],PolyVal [0,1,1,1,0,1,1,0],PolyVal [0,1,1,1,1,0,0,1]],VectorVal [PolyVal [1,0,1,0,0,0,0,1],PolyVal [1,0,1,1,1,0,1,0],PolyVal [0,1,1,0,0,0,0,1],PolyVal [0,1,0,0,0,0,1,0],PolyVal [0,1,1,1,0,1,0,0],PolyVal [1,0,0,1,0,0,0,0],PolyVal [1,0,0,0,1,0,1,0],PolyVal [1,0,1,0,0,1,0,0],PolyVal [0,1,1,1,0,1,0,1],PolyVal [0,1,1,1,0,0,1,0],PolyVal [1,1,1,0,0,1,1,0],PolyVal [1,0,1,0,1,0,0,0],PolyVal [1,0,0,0,1,1,1,0],PolyVal [0,0,1,0,1,0,1,1],PolyVal [1,1,0,1,0,1,0,0],PolyVal [0,1,0,1,1,1,0,1]]],VectorVal [IntegerVal 0,IntegerVal 127,IntegerVal 255,IntegerVal 84,IntegerVal 0,IntegerVal 128,IntegerVal 0,IntegerVal 0,IntegerVal 0,IntegerVal 127,IntegerVal 255,IntegerVal 0,IntegerVal 0,IntegerVal 128,IntegerVal 127,IntegerVal 255]], start_saturated = False}";
      int reported = 0;
      arg1.val[0] = vcombine_p8(vcreate_p8(UINT64_C(0x974ac97116ca4201)),
                                vcreate_p8(UINT64_C(0x814951941cda48cb)));
      arg1.val[1] = vcombine_p8(vcreate_p8(UINT64_C(0xac72eb021b8dbdec)),
                                vcreate_p8(UINT64_C(0x9e6e5ea056d39da9)));
      arg1.val[2] = vcombine_p8(vcreate_p8(UINT64_C(0x2551092e42865d85)),
                                vcreate_p8(UINT64_C(0xba2bd47115674eae)));
      arg2 = vcombine_u8(vcreate_u8(UINT64_C(0x0000800054ff7f00)),
                         vcreate_u8(UINT64_C(0xff7f800000ff7f00)));
      clear_neon_saturated();
      //  Expect: "result" = 00000001010000010101000100000001
      result = vqtbl3q_p8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p8(result), 0);
         exp = UINT64_C(0x0101000100000001);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p8(result), 1);
         exp = UINT64_C(0x0000000101000001);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2236() {

{
   {
      uint8x16x4_t arg1;
      uint8x8_t arg2;
      uint8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"tbl\", fnname = \"vqtbl4_u8\", rettype = \"uint8x8_t\", argtypes = \"[uint8x16x4_t,uint8x8_t]\", vals = [ArrayVal [VectorVal [IntegerVal 0,IntegerVal 255,IntegerVal 128,IntegerVal 128,IntegerVal 255,IntegerVal 128,IntegerVal 0,IntegerVal 0,IntegerVal 255,IntegerVal 0,IntegerVal 127,IntegerVal 128,IntegerVal 255,IntegerVal 97,IntegerVal 0,IntegerVal 127],VectorVal [IntegerVal 0,IntegerVal 127,IntegerVal 46,IntegerVal 255,IntegerVal 127,IntegerVal 127,IntegerVal 128,IntegerVal 0,IntegerVal 255,IntegerVal 255,IntegerVal 255,IntegerVal 255,IntegerVal 128,IntegerVal 127,IntegerVal 255,IntegerVal 255],VectorVal [IntegerVal 128,IntegerVal 255,IntegerVal 255,IntegerVal 127,IntegerVal 255,IntegerVal 128,IntegerVal 36,IntegerVal 255,IntegerVal 0,IntegerVal 0,IntegerVal 128,IntegerVal 127,IntegerVal 0,IntegerVal 127,IntegerVal 0,IntegerVal 196],VectorVal [IntegerVal 127,IntegerVal 0,IntegerVal 127,IntegerVal 255,IntegerVal 0,IntegerVal 128,IntegerVal 128,IntegerVal 0,IntegerVal 127,IntegerVal 0,IntegerVal 128,IntegerVal 255,IntegerVal 255,IntegerVal 255,IntegerVal 255,IntegerVal 128]],VectorVal [IntegerVal 216,IntegerVal 127,IntegerVal 159,IntegerVal 127,IntegerVal 179,IntegerVal 128,IntegerVal 150,IntegerVal 128]], start_saturated = True}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1.val[0] = vcombine_u8(vcreate_u8(UINT64_C(0x000080ff8080ff00)),
                                vcreate_u8(UINT64_C(0x7f0061ff807f00ff)));
      arg1.val[1] = vcombine_u8(vcreate_u8(UINT64_C(0x00807f7fff2e7f00)),
                                vcreate_u8(UINT64_C(0xffff7f80ffffffff)));
      arg1.val[2] = vcombine_u8(vcreate_u8(UINT64_C(0xff2480ff7fffff80)),
                                vcreate_u8(UINT64_C(0xc4007f007f800000)));
      arg1.val[3] = vcombine_u8(vcreate_u8(UINT64_C(0x00808000ff7f007f)),
                                vcreate_u8(UINT64_C(0x80ffffffff80007f)));
      arg2 = vcreate_u8(UINT64_C(0x809680b37f9f7fd8));
      set_neon_saturated();
      //  Expect: "result" = 0000000000000000
      result = vqtbl4_u8(arg1, arg2);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u8(result), 0);
      exp = 0;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2237() {

{
   {
      uint8x16x4_t arg1;
      uint8x16_t arg2;
      uint8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"tbl\", fnname = \"vqtbl4q_u8\", rettype = \"uint8x16_t\", argtypes = \"[uint8x16x4_t,uint8x16_t]\", vals = [ArrayVal [VectorVal [IntegerVal 128,IntegerVal 0,IntegerVal 127,IntegerVal 128,IntegerVal 127,IntegerVal 255,IntegerVal 128,IntegerVal 255,IntegerVal 128,IntegerVal 255,IntegerVal 128,IntegerVal 255,IntegerVal 255,IntegerVal 0,IntegerVal 219,IntegerVal 127],VectorVal [IntegerVal 0,IntegerVal 255,IntegerVal 128,IntegerVal 128,IntegerVal 130,IntegerVal 255,IntegerVal 0,IntegerVal 128,IntegerVal 127,IntegerVal 255,IntegerVal 0,IntegerVal 255,IntegerVal 128,IntegerVal 0,IntegerVal 163,IntegerVal 128],VectorVal [IntegerVal 255,IntegerVal 128,IntegerVal 127,IntegerVal 173,IntegerVal 127,IntegerVal 0,IntegerVal 66,IntegerVal 255,IntegerVal 105,IntegerVal 127,IntegerVal 252,IntegerVal 255,IntegerVal 255,IntegerVal 99,IntegerVal 44,IntegerVal 128],VectorVal [IntegerVal 255,IntegerVal 80,IntegerVal 0,IntegerVal 255,IntegerVal 175,IntegerVal 128,IntegerVal 255,IntegerVal 0,IntegerVal 128,IntegerVal 28,IntegerVal 0,IntegerVal 127,IntegerVal 255,IntegerVal 128,IntegerVal 136,IntegerVal 255]],VectorVal [IntegerVal 128,IntegerVal 127,IntegerVal 127,IntegerVal 249,IntegerVal 127,IntegerVal 128,IntegerVal 128,IntegerVal 0,IntegerVal 28,IntegerVal 127,IntegerVal 0,IntegerVal 97,IntegerVal 128,IntegerVal 213,IntegerVal 77,IntegerVal 57]], start_saturated = False}";
      int reported = 0;
      arg1.val[0] = vcombine_u8(vcreate_u8(UINT64_C(0xff80ff7f807f0080)),
                                vcreate_u8(UINT64_C(0x7fdb00ffff80ff80)));
      arg1.val[1] = vcombine_u8(vcreate_u8(UINT64_C(0x8000ff828080ff00)),
                                vcreate_u8(UINT64_C(0x80a30080ff00ff7f)));
      arg1.val[2] = vcombine_u8(vcreate_u8(UINT64_C(0xff42007fad7f80ff)),
                                vcreate_u8(UINT64_C(0x802c63fffffc7f69)));
      arg1.val[3] = vcombine_u8(vcreate_u8(UINT64_C(0x00ff80afff0050ff)),
                                vcreate_u8(UINT64_C(0xff8880ff7f001c80)));
      arg2 = vcombine_u8(vcreate_u8(UINT64_C(0x0080807ff97f7f80)),
                         vcreate_u8(UINT64_C(0x394dd58061007f1c)));
      clear_neon_saturated();
      //  Expect: "result" = 1c000000008000808000000000000000
      result = vqtbl4q_u8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 0);
         exp = UINT64_C(0x8000000000000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 1);
         exp = UINT64_C(0x1c00000000800080);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2238() {

{
   {
      int8x16x4_t arg1;
      uint8x8_t arg2;
      int8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"tbl\", fnname = \"vqtbl4_s8\", rettype = \"int8x8_t\", argtypes = \"[int8x16x4_t,uint8x8_t]\", vals = [ArrayVal [VectorVal [IntegerVal (-1),IntegerVal (-128),IntegerVal (-128),IntegerVal 0,IntegerVal (-8),IntegerVal (-128),IntegerVal (-1),IntegerVal (-128),IntegerVal (-128),IntegerVal 0,IntegerVal 127,IntegerVal 0,IntegerVal 127,IntegerVal (-128),IntegerVal 0,IntegerVal (-128)],VectorVal [IntegerVal 57,IntegerVal (-128),IntegerVal 127,IntegerVal (-128),IntegerVal (-128),IntegerVal 3,IntegerVal 0,IntegerVal 127,IntegerVal (-1),IntegerVal (-1),IntegerVal 127,IntegerVal (-128),IntegerVal 0,IntegerVal 0,IntegerVal 0,IntegerVal 127],VectorVal [IntegerVal (-128),IntegerVal (-1),IntegerVal 48,IntegerVal 127,IntegerVal 127,IntegerVal 0,IntegerVal (-128),IntegerVal 0,IntegerVal (-1),IntegerVal 127,IntegerVal 127,IntegerVal (-128),IntegerVal 0,IntegerVal 127,IntegerVal (-128),IntegerVal 0],VectorVal [IntegerVal 0,IntegerVal (-128),IntegerVal 126,IntegerVal 127,IntegerVal 127,IntegerVal (-1),IntegerVal 0,IntegerVal 0,IntegerVal 71,IntegerVal 0,IntegerVal (-128),IntegerVal (-128),IntegerVal (-27),IntegerVal (-128),IntegerVal (-25),IntegerVal 0]],VectorVal [IntegerVal 121,IntegerVal 255,IntegerVal 56,IntegerVal 128,IntegerVal 128,IntegerVal 254,IntegerVal 0,IntegerVal 128]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1.val[0] = vcombine_s8(vcreate_s8(UINT64_C(0x80ff80f8008080ff)),
                                vcreate_s8(UINT64_C(0x8000807f007f0080)));
      arg1.val[1] = vcombine_s8(vcreate_s8(UINT64_C(0x7f000380807f8039)),
                                vcreate_s8(UINT64_C(0x7f000000807fffff)));
      arg1.val[2] = vcombine_s8(vcreate_s8(UINT64_C(0x0080007f7f30ff80)),
                                vcreate_s8(UINT64_C(0x00807f00807f7fff)));
      arg1.val[3] = vcombine_s8(vcreate_s8(UINT64_C(0x0000ff7f7f7e8000)),
                                vcreate_s8(UINT64_C(0x00e780e580800047)));
      arg2 = vcreate_u8(UINT64_C(0x8000fe808038ff79));
      clear_neon_saturated();
      //  Expect: "result" = 00ff000000470000
      result = vqtbl4_s8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s8(result), 0);
      exp = UINT64_C(0x00ff000000470000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2239() {

{
   {
      int8x16x4_t arg1;
      uint8x16_t arg2;
      int8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"tbl\", fnname = \"vqtbl4q_s8\", rettype = \"int8x16_t\", argtypes = \"[int8x16x4_t,uint8x16_t]\", vals = [ArrayVal [VectorVal [IntegerVal (-115),IntegerVal (-128),IntegerVal 0,IntegerVal (-60),IntegerVal 0,IntegerVal 0,IntegerVal 127,IntegerVal (-40),IntegerVal 127,IntegerVal (-1),IntegerVal (-1),IntegerVal 0,IntegerVal 127,IntegerVal (-1),IntegerVal (-128),IntegerVal 66],VectorVal [IntegerVal 0,IntegerVal (-128),IntegerVal 120,IntegerVal (-1),IntegerVal 127,IntegerVal 103,IntegerVal 127,IntegerVal 0,IntegerVal 0,IntegerVal 0,IntegerVal (-128),IntegerVal (-1),IntegerVal 76,IntegerVal 0,IntegerVal (-1),IntegerVal (-64)],VectorVal [IntegerVal (-128),IntegerVal 127,IntegerVal 109,IntegerVal 0,IntegerVal (-1),IntegerVal (-9),IntegerVal (-1),IntegerVal 0,IntegerVal 0,IntegerVal 18,IntegerVal 127,IntegerVal 0,IntegerVal (-128),IntegerVal 127,IntegerVal 127,IntegerVal (-1)],VectorVal [IntegerVal 46,IntegerVal (-1),IntegerVal 127,IntegerVal (-1),IntegerVal 0,IntegerVal (-41),IntegerVal (-128),IntegerVal (-1),IntegerVal 127,IntegerVal 127,IntegerVal 0,IntegerVal (-128),IntegerVal (-1),IntegerVal 0,IntegerVal (-1),IntegerVal 127]],VectorVal [IntegerVal 255,IntegerVal 128,IntegerVal 127,IntegerVal 0,IntegerVal 255,IntegerVal 255,IntegerVal 252,IntegerVal 255,IntegerVal 184,IntegerVal 128,IntegerVal 128,IntegerVal 255,IntegerVal 190,IntegerVal 127,IntegerVal 255,IntegerVal 0]], start_saturated = False}";
      int reported = 0;
      arg1.val[0] = vcombine_s8(vcreate_s8(UINT64_C(0xd87f0000c400808d)),
                                vcreate_s8(UINT64_C(0x4280ff7f00ffff7f)));
      arg1.val[1] = vcombine_s8(vcreate_s8(UINT64_C(0x007f677fff788000)),
                                vcreate_s8(UINT64_C(0xc0ff004cff800000)));
      arg1.val[2] = vcombine_s8(vcreate_s8(UINT64_C(0x00fff7ff006d7f80)),
                                vcreate_s8(UINT64_C(0xff7f7f80007f1200)));
      arg1.val[3] = vcombine_s8(vcreate_s8(UINT64_C(0xff80d700ff7fff2e)),
                                vcreate_s8(UINT64_C(0x7fff00ff80007f7f)));
      arg2 = vcombine_u8(vcreate_u8(UINT64_C(0xfffcffff007f80ff)),
                         vcreate_u8(UINT64_C(0x00ff7fbeff8080b8)));
      clear_neon_saturated();
      //  Expect: "result" = 8d00000000000000000000008d000000
      result = vqtbl4q_s8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result), 0);
         exp = UINT64_C(0x000000008d000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result), 1);
         exp = UINT64_C(0x8d00000000000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2240() {

{
   {
      poly8x16x4_t arg1;
      uint8x8_t arg2;
      poly8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"tbl\", fnname = \"vqtbl4_p8\", rettype = \"poly8x8_t\", argtypes = \"[poly8x16x4_t,uint8x8_t]\", vals = [ArrayVal [VectorVal [PolyVal [1,1,1,0,1,0,0,1],PolyVal [0,0,1,1,1,0,1,1],PolyVal [1,1,1,1,1,1,0,1],PolyVal [0,1,0,0,1,0,0,0],PolyVal [0,1,0,0,0,1,1,1],PolyVal [0,1,1,1,0,0,0,1],PolyVal [1,1,0,1,1,1,0,0],PolyVal [0,0,1,1,1,1,1,0],PolyVal [0,1,1,0,0,0,1,1],PolyVal [0,0,0,0,0,1,0,1],PolyVal [1,0,1,0,0,0,0,1],PolyVal [0,0,0,1,1,1,0,1],PolyVal [1,0,1,0,0,1,0,1],PolyVal [1,1,1,0,0,0,1,1],PolyVal [0,0,1,0,0,0,0,1],PolyVal [0,1,1,1,0,1,0,1]],VectorVal [PolyVal [1,1,1,0,1,0,1,0],PolyVal [0,1,0,0,0,1,0,0],PolyVal [1,1,1,0,0,1,1,0],PolyVal [0,1,1,0,0,1,1,1],PolyVal [1,0,1,0,0,1,0,0],PolyVal [1,1,0,0,0,0,1,0],PolyVal [0,1,1,0,0,0,0,1],PolyVal [0,0,0,0,0,0,0,1],PolyVal [1,0,0,0,0,0,0,0],PolyVal [1,0,1,0,1,0,1,0],PolyVal [0,1,0,0,1,0,1,1],PolyVal [1,0,0,0,0,1,0,0],PolyVal [0,1,0,0,1,0,1,0],PolyVal [1,1,1,0,1,1,1,1],PolyVal [0,1,0,1,1,1,0,1],PolyVal [1,0,1,1,1,1,1,0]],VectorVal [PolyVal [1,0,0,0,0,1,1,0],PolyVal [1,0,0,0,1,1,1,1],PolyVal [0,1,1,0,1,1,0,1],PolyVal [0,1,1,1,0,0,0,0],PolyVal [0,1,1,1,1,1,0,0],PolyVal [1,0,0,1,0,0,0,0],PolyVal [1,1,1,1,0,0,1,1],PolyVal [0,1,0,1,1,1,1,1],PolyVal [1,0,0,1,0,0,0,0],PolyVal [0,1,0,0,1,0,1,1],PolyVal [1,0,1,1,0,1,1,0],PolyVal [0,1,1,1,1,0,1,1],PolyVal [0,0,1,1,0,0,1,0],PolyVal [0,1,1,0,1,0,0,0],PolyVal [1,1,0,0,1,1,1,0],PolyVal [0,0,1,1,0,1,1,1]],VectorVal [PolyVal [1,1,0,1,0,1,1,0],PolyVal [0,1,1,0,1,1,1,1],PolyVal [1,1,1,1,0,1,0,0],PolyVal [1,1,0,1,1,1,1,1],PolyVal [0,1,1,1,1,1,0,1],PolyVal [0,0,1,0,0,1,0,0],PolyVal [1,1,1,0,1,1,0,0],PolyVal [1,1,1,0,1,0,0,0],PolyVal [1,0,1,0,0,0,1,0],PolyVal [1,0,1,1,0,1,1,1],PolyVal [1,1,0,1,0,1,0,1],PolyVal [1,1,0,1,1,1,1,0],PolyVal [1,0,1,1,1,0,1,1],PolyVal [1,0,1,0,1,0,1,1],PolyVal [0,1,0,0,1,1,0,1],PolyVal [1,1,1,1,1,0,0,1]]],VectorVal [IntegerVal 255,IntegerVal 128,IntegerVal 128,IntegerVal 127,IntegerVal 82,IntegerVal 128,IntegerVal 127,IntegerVal 127]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1.val[0] = vcombine_p8(vcreate_p8(UINT64_C(0x7c3b8ee212bfdc97)),
                                vcreate_p8(UINT64_C(0xae84c7a5b885a0c6)));
      arg1.val[1] = vcombine_p8(vcreate_p8(UINT64_C(0x80864325e6672257)),
                                vcreate_p8(UINT64_C(0x7dbaf75221d25501)));
      arg1.val[2] = vcombine_p8(vcreate_p8(UINT64_C(0xfacf093e0eb6f161)),
                                vcreate_p8(UINT64_C(0xec73164cde6dd209)));
      arg1.val[3] = vcombine_p8(vcreate_p8(UINT64_C(0x173724befb2ff66b)),
                                vcreate_p8(UINT64_C(0x9fb2d5dd7babed45)));
      arg2 = vcreate_u8(UINT64_C(0x7f7f80527f8080ff));
      clear_neon_saturated();
      //  Expect: "result" = 0000000000000000
      result = vqtbl4_p8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_p8(result), 0);
      exp = 0;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2241() {

{
   {
      poly8x16x4_t arg1;
      uint8x16_t arg2;
      poly8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"tbl\", fnname = \"vqtbl4q_p8\", rettype = \"poly8x16_t\", argtypes = \"[poly8x16x4_t,uint8x16_t]\", vals = [ArrayVal [VectorVal [PolyVal [1,0,0,0,0,1,1,0],PolyVal [1,0,0,1,1,0,0,0],PolyVal [1,1,0,1,1,0,0,1],PolyVal [0,1,0,1,1,1,1,0],PolyVal [1,1,0,1,0,1,0,0],PolyVal [0,0,0,0,0,0,1,1],PolyVal [0,1,1,0,0,1,0,0],PolyVal [0,0,0,1,1,0,0,1],PolyVal [1,1,1,1,1,0,0,1],PolyVal [1,0,0,0,1,0,1,1],PolyVal [0,1,1,0,1,1,0,0],PolyVal [1,0,0,1,0,1,1,0],PolyVal [1,0,1,0,1,0,1,0],PolyVal [1,0,1,0,1,0,0,1],PolyVal [0,0,1,0,0,1,1,1],PolyVal [1,1,0,1,0,0,0,1]],VectorVal [PolyVal [0,0,0,1,1,1,0,1],PolyVal [1,0,1,0,0,1,0,1],PolyVal [0,1,0,0,1,1,0,1],PolyVal [1,1,1,1,0,0,1,1],PolyVal [0,1,0,0,1,1,1,1],PolyVal [1,1,1,1,1,1,1,1],PolyVal [1,0,1,1,0,0,1,0],PolyVal [0,1,1,0,1,0,1,1],PolyVal [0,0,1,1,0,1,0,1],PolyVal [1,1,1,0,0,1,1,0],PolyVal [1,0,1,1,0,1,1,0],PolyVal [0,1,0,0,1,0,0,1],PolyVal [1,0,1,1,0,1,1,1],PolyVal [0,1,1,1,0,1,0,0],PolyVal [0,1,0,1,0,0,1,0],PolyVal [1,0,1,0,0,1,0,0]],VectorVal [PolyVal [0,1,1,0,0,0,0,1],PolyVal [1,0,1,0,1,1,1,0],PolyVal [0,0,1,1,0,1,1,0],PolyVal [1,0,0,1,0,1,1,0],PolyVal [1,1,1,1,1,1,0,0],PolyVal [0,1,0,1,1,1,0,1],PolyVal [0,0,0,1,1,0,1,0],PolyVal [1,1,1,1,0,0,0,0],PolyVal [1,1,0,1,0,0,0,0],PolyVal [1,0,0,0,0,1,0,1],PolyVal [1,0,1,1,1,0,1,0],PolyVal [1,1,1,0,0,1,1,0],PolyVal [1,1,0,1,1,1,0,0],PolyVal [1,1,1,0,0,1,0,0],PolyVal [1,1,1,1,0,1,0,1],PolyVal [0,1,0,0,1,0,0,0]],VectorVal [PolyVal [1,0,0,0,1,0,0,1],PolyVal [0,0,0,0,1,0,1,1],PolyVal [0,1,1,0,0,1,0,1],PolyVal [0,1,1,0,1,1,1,0],PolyVal [0,0,0,1,0,0,1,1],PolyVal [0,0,0,0,0,0,1,1],PolyVal [1,1,0,1,1,1,1,1],PolyVal [1,0,0,0,1,0,1,1],PolyVal [0,1,1,0,0,1,1,1],PolyVal [1,0,0,1,1,1,1,0],PolyVal [0,0,1,1,1,1,0,1],PolyVal [1,1,0,1,0,1,0,0],PolyVal [1,0,1,0,1,1,0,0],PolyVal [0,0,0,1,0,1,0,1],PolyVal [1,1,1,0,0,0,0,1],PolyVal [0,1,0,1,1,0,1,1]]],VectorVal [IntegerVal 127,IntegerVal 255,IntegerVal 121,IntegerVal 183,IntegerVal 0,IntegerVal 30,IntegerVal 0,IntegerVal 255,IntegerVal 127,IntegerVal 255,IntegerVal 214,IntegerVal 127,IntegerVal 0,IntegerVal 128,IntegerVal 255,IntegerVal 108]], start_saturated = True}";
      int reported = 0;
      arg1.val[0] = vcombine_p8(vcreate_p8(UINT64_C(0x9826c02b7a9b1961)),
                                vcreate_p8(UINT64_C(0x8be495556936d19f)));
      arg1.val[1] = vcombine_p8(vcreate_p8(UINT64_C(0xd64dfff2cfb2a5b8)),
                                vcreate_p8(UINT64_C(0x254a2eed926d67ac)));
      arg1.val[2] = vcombine_p8(vcreate_p8(UINT64_C(0x0f58ba3f696c7586)),
                                vcreate_p8(UINT64_C(0x12af273b675da10b)));
      arg1.val[3] = vcombine_p8(vcreate_p8(UINT64_C(0xd1fbc0c876a6d091)),
                                vcreate_p8(UINT64_C(0xda87a8352bbc79e6)));
      arg2 = vcombine_u8(vcreate_u8(UINT64_C(0xff001e00b779ff7f)),
                         vcreate_u8(UINT64_C(0x6cff80007fd6ff7f)));
      set_neon_saturated();
      //  Expect: "result" = 000000610000000000614a6100000000
      result = vqtbl4q_p8(arg1, arg2);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p8(result), 0);
         exp = UINT64_C(0x00614a6100000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p8(result), 1);
         exp = UINT64_C(0x0000006100000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2242() {

{
   {
      uint8x8_t arg1;
      uint8x16_t arg2;
      uint8x8_t arg3;
      uint8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"tbx\", fnname = \"vqtbx1_u8\", rettype = \"uint8x8_t\", argtypes = \"[uint8x8_t,uint8x16_t,uint8x8_t]\", vals = [VectorVal [IntegerVal 255,IntegerVal 127,IntegerVal 128,IntegerVal 0,IntegerVal 0,IntegerVal 255,IntegerVal 128,IntegerVal 128],VectorVal [IntegerVal 151,IntegerVal 255,IntegerVal 0,IntegerVal 255,IntegerVal 255,IntegerVal 255,IntegerVal 128,IntegerVal 255,IntegerVal 128,IntegerVal 127,IntegerVal 0,IntegerVal 0,IntegerVal 127,IntegerVal 128,IntegerVal 0,IntegerVal 128],VectorVal [IntegerVal 127,IntegerVal 128,IntegerVal 0,IntegerVal 169,IntegerVal 255,IntegerVal 0,IntegerVal 15,IntegerVal 0]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u8(UINT64_C(0x8080ff0000807fff));
      arg2 = vcombine_u8(vcreate_u8(UINT64_C(0xff80ffffff00ff97)),
                         vcreate_u8(UINT64_C(0x8000807f00007f80)));
      arg3 = vcreate_u8(UINT64_C(0x000f00ffa900807f));
      clear_neon_saturated();
      //  Expect: "result" = 9780970000977fff
      result = vqtbx1_u8(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u8(result), 0);
      exp = UINT64_C(0x9780970000977fff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2243() {

{
   {
      uint8x16_t arg1;
      uint8x16_t arg2;
      uint8x16_t arg3;
      uint8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"tbx\", fnname = \"vqtbx1q_u8\", rettype = \"uint8x16_t\", argtypes = \"[uint8x16_t,uint8x16_t,uint8x16_t]\", vals = [VectorVal [IntegerVal 0,IntegerVal 94,IntegerVal 123,IntegerVal 0,IntegerVal 0,IntegerVal 255,IntegerVal 0,IntegerVal 0,IntegerVal 128,IntegerVal 127,IntegerVal 255,IntegerVal 255,IntegerVal 128,IntegerVal 0,IntegerVal 95,IntegerVal 127],VectorVal [IntegerVal 255,IntegerVal 0,IntegerVal 128,IntegerVal 127,IntegerVal 85,IntegerVal 84,IntegerVal 255,IntegerVal 30,IntegerVal 255,IntegerVal 127,IntegerVal 49,IntegerVal 0,IntegerVal 214,IntegerVal 0,IntegerVal 0,IntegerVal 255],VectorVal [IntegerVal 128,IntegerVal 128,IntegerVal 127,IntegerVal 255,IntegerVal 128,IntegerVal 127,IntegerVal 140,IntegerVal 128,IntegerVal 128,IntegerVal 0,IntegerVal 0,IntegerVal 128,IntegerVal 255,IntegerVal 0,IntegerVal 0,IntegerVal 44]], start_saturated = True}";
      int reported = 0;
      arg1 = vcombine_u8(vcreate_u8(UINT64_C(0x0000ff00007b5e00)),
                         vcreate_u8(UINT64_C(0x7f5f0080ffff7f80)));
      arg2 = vcombine_u8(vcreate_u8(UINT64_C(0x1eff54557f8000ff)),
                         vcreate_u8(UINT64_C(0xff0000d600317fff)));
      arg3 = vcombine_u8(vcreate_u8(UINT64_C(0x808c7f80ff7f8080)),
                         vcreate_u8(UINT64_C(0x2c0000ff80000080)));
      set_neon_saturated();
      //  Expect: "result" = 7fffff80ffffff800000ff00007b5e00
      result = vqtbx1q_u8(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 0);
         exp = UINT64_C(0x0000ff00007b5e00);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 1);
         exp = UINT64_C(0x7fffff80ffffff80);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2244() {

{
   {
      int8x8_t arg1;
      int8x16_t arg2;
      uint8x8_t arg3;
      int8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"tbx\", fnname = \"vqtbx1_s8\", rettype = \"int8x8_t\", argtypes = \"[int8x8_t,int8x16_t,uint8x8_t]\", vals = [VectorVal [IntegerVal 127,IntegerVal (-128),IntegerVal (-22),IntegerVal (-26),IntegerVal 127,IntegerVal 127,IntegerVal (-19),IntegerVal 0],VectorVal [IntegerVal (-1),IntegerVal 111,IntegerVal 0,IntegerVal 99,IntegerVal (-1),IntegerVal 127,IntegerVal 0,IntegerVal 0,IntegerVal (-1),IntegerVal 0,IntegerVal (-128),IntegerVal (-45),IntegerVal 127,IntegerVal (-1),IntegerVal (-1),IntegerVal (-128)],VectorVal [IntegerVal 196,IntegerVal 54,IntegerVal 225,IntegerVal 128,IntegerVal 255,IntegerVal 0,IntegerVal 127,IntegerVal 255]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s8(UINT64_C(0x00ed7f7fe6ea807f));
      arg2 = vcombine_s8(vcreate_s8(UINT64_C(0x00007fff63006fff)),
                         vcreate_s8(UINT64_C(0x80ffff7fd38000ff)));
      arg3 = vcreate_u8(UINT64_C(0xff7f00ff80e136c4));
      clear_neon_saturated();
      //  Expect: "result" = 00edff7fe6ea807f
      result = vqtbx1_s8(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s8(result), 0);
      exp = UINT64_C(0x00edff7fe6ea807f);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2245() {

{
   {
      int8x16_t arg1;
      int8x16_t arg2;
      uint8x16_t arg3;
      int8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"tbx\", fnname = \"vqtbx1q_s8\", rettype = \"int8x16_t\", argtypes = \"[int8x16_t,int8x16_t,uint8x16_t]\", vals = [VectorVal [IntegerVal 127,IntegerVal (-1),IntegerVal (-51),IntegerVal 0,IntegerVal (-128),IntegerVal (-128),IntegerVal (-1),IntegerVal (-1),IntegerVal (-128),IntegerVal (-128),IntegerVal (-1),IntegerVal 127,IntegerVal (-128),IntegerVal (-22),IntegerVal 0,IntegerVal (-20)],VectorVal [IntegerVal 127,IntegerVal 127,IntegerVal (-124),IntegerVal 127,IntegerVal (-1),IntegerVal 127,IntegerVal (-1),IntegerVal (-128),IntegerVal (-57),IntegerVal (-128),IntegerVal 67,IntegerVal (-1),IntegerVal 0,IntegerVal (-128),IntegerVal (-1),IntegerVal 0],VectorVal [IntegerVal 72,IntegerVal 127,IntegerVal 0,IntegerVal 128,IntegerVal 0,IntegerVal 255,IntegerVal 128,IntegerVal 255,IntegerVal 0,IntegerVal 127,IntegerVal 128,IntegerVal 0,IntegerVal 0,IntegerVal 11,IntegerVal 227,IntegerVal 128]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s8(vcreate_s8(UINT64_C(0xffff808000cdff7f)),
                         vcreate_s8(UINT64_C(0xec00ea807fff8080)));
      arg2 = vcombine_s8(vcreate_s8(UINT64_C(0x80ff7fff7f847f7f)),
                         vcreate_s8(UINT64_C(0x00ff8000ff4380c7)));
      arg3 = vcombine_u8(vcreate_u8(UINT64_C(0xff80ff0080007f48)),
                         vcreate_u8(UINT64_C(0x80e30b0000807f00)));
      clear_neon_saturated();
      //  Expect: "result" = ec00ff7f7fff807fffff807f007fff7f
      result = vqtbx1q_s8(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result), 0);
         exp = UINT64_C(0xffff807f007fff7f);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result), 1);
         exp = UINT64_C(0xec00ff7f7fff807f);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2246() {

{
   {
      poly8x8_t arg1;
      poly8x16_t arg2;
      uint8x8_t arg3;
      poly8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"tbx\", fnname = \"vqtbx1_p8\", rettype = \"poly8x8_t\", argtypes = \"[poly8x8_t,poly8x16_t,uint8x8_t]\", vals = [VectorVal [PolyVal [0,0,0,0,1,1,1,1],PolyVal [1,0,0,0,0,1,1,1],PolyVal [1,1,1,1,1,0,1,0],PolyVal [0,0,0,0,1,1,0,0],PolyVal [0,0,1,1,1,1,1,0],PolyVal [0,0,0,1,1,0,1,1],PolyVal [0,1,1,1,0,1,1,1],PolyVal [1,1,0,1,0,1,1,1]],VectorVal [PolyVal [1,1,0,1,0,0,0,0],PolyVal [0,0,0,1,0,0,0,1],PolyVal [1,0,1,1,0,0,1,1],PolyVal [0,0,1,0,1,1,1,1],PolyVal [0,1,0,1,1,0,0,1],PolyVal [1,1,1,0,0,1,1,0],PolyVal [1,0,0,1,1,1,1,1],PolyVal [1,0,0,0,1,1,0,0],PolyVal [0,1,0,1,1,1,1,1],PolyVal [1,1,0,1,1,1,0,1],PolyVal [1,0,1,1,1,1,1,0],PolyVal [1,0,0,1,1,0,0,0],PolyVal [0,0,1,0,1,0,0,1],PolyVal [0,0,1,0,0,1,0,0],PolyVal [1,0,0,1,1,0,0,1],PolyVal [0,0,1,0,1,0,0,1]],VectorVal [IntegerVal 128,IntegerVal 255,IntegerVal 127,IntegerVal 127,IntegerVal 199,IntegerVal 159,IntegerVal 46,IntegerVal 255]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_p8(UINT64_C(0xebeed87c305fe1f0));
      arg2 = vcombine_p8(vcreate_p8(UINT64_C(0x31f9679af4cd880b)),
                         vcreate_p8(UINT64_C(0x94992494197dbbfa)));
      arg3 = vcreate_u8(UINT64_C(0xff2e9fc77f7fff80));
      clear_neon_saturated();
      //  Expect: "result" = ebeed87c305fe1f0
      result = vqtbx1_p8(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_p8(result), 0);
      exp = UINT64_C(0xebeed87c305fe1f0);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2247() {

{
   {
      poly8x16_t arg1;
      poly8x16_t arg2;
      uint8x16_t arg3;
      poly8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"tbx\", fnname = \"vqtbx1q_p8\", rettype = \"poly8x16_t\", argtypes = \"[poly8x16_t,poly8x16_t,uint8x16_t]\", vals = [VectorVal [PolyVal [1,0,0,1,0,1,0,0],PolyVal [0,1,0,1,1,1,1,1],PolyVal [0,0,1,0,1,1,0,1],PolyVal [0,0,1,1,0,1,1,1],PolyVal [1,1,1,0,1,0,1,0],PolyVal [0,0,0,1,1,1,0,1],PolyVal [1,0,0,1,1,0,0,1],PolyVal [1,0,0,0,0,1,1,0],PolyVal [0,1,1,0,0,1,0,1],PolyVal [1,1,0,0,0,1,0,1],PolyVal [1,0,1,1,0,1,1,1],PolyVal [0,0,1,1,1,1,1,1],PolyVal [1,0,1,0,1,1,1,1],PolyVal [0,1,1,0,0,1,1,1],PolyVal [0,0,0,1,0,0,0,0],PolyVal [1,0,0,1,0,0,0,1]],VectorVal [PolyVal [0,0,1,0,0,1,0,1],PolyVal [1,0,1,0,0,0,0,0],PolyVal [1,0,0,0,0,1,0,0],PolyVal [1,0,1,1,0,0,0,0],PolyVal [0,1,0,0,0,1,0,1],PolyVal [1,1,1,0,0,1,0,0],PolyVal [0,0,0,1,1,0,0,0],PolyVal [1,0,0,1,1,1,0,0],PolyVal [1,1,0,0,0,1,0,1],PolyVal [1,1,1,0,1,1,1,1],PolyVal [0,0,1,0,0,0,0,0],PolyVal [0,1,0,0,1,1,1,0],PolyVal [1,0,0,1,1,1,0,1],PolyVal [1,0,0,1,0,1,1,0],PolyVal [0,1,1,1,0,0,1,1],PolyVal [1,0,0,0,0,1,1,1]],VectorVal [IntegerVal 138,IntegerVal 127,IntegerVal 0,IntegerVal 205,IntegerVal 0,IntegerVal 0,IntegerVal 127,IntegerVal 0,IntegerVal 128,IntegerVal 127,IntegerVal 128,IntegerVal 255,IntegerVal 128,IntegerVal 128,IntegerVal 128,IntegerVal 0]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_p8(vcreate_p8(UINT64_C(0x6199b857ecb4fa29)),
                         vcreate_p8(UINT64_C(0x8908e6f5fceda3a6)));
      arg2 = vcombine_p8(vcreate_p8(UINT64_C(0x391827a20d2105a4)),
                         vcreate_p8(UINT64_C(0xe1ce69b97204f7a3)));
      arg3 = vcombine_u8(vcreate_u8(UINT64_C(0x007f0000cd007f8a)),
                         vcreate_u8(UINT64_C(0x00808080ff807f80)));
      clear_neon_saturated();
      //  Expect: "result" = a408e6f5fceda3a6a499a4a4eca4fa29
      result = vqtbx1q_p8(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p8(result), 0);
         exp = UINT64_C(0xa499a4a4eca4fa29);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p8(result), 1);
         exp = UINT64_C(0xa408e6f5fceda3a6);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2248() {

{
   {
      uint8x8_t arg1;
      uint8x16x2_t arg2;
      uint8x8_t arg3;
      uint8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"tbx\", fnname = \"vqtbx2_u8\", rettype = \"uint8x8_t\", argtypes = \"[uint8x8_t,uint8x16x2_t,uint8x8_t]\", vals = [VectorVal [IntegerVal 128,IntegerVal 171,IntegerVal 127,IntegerVal 225,IntegerVal 195,IntegerVal 35,IntegerVal 201,IntegerVal 128],ArrayVal [VectorVal [IntegerVal 68,IntegerVal 0,IntegerVal 127,IntegerVal 127,IntegerVal 123,IntegerVal 255,IntegerVal 234,IntegerVal 255,IntegerVal 255,IntegerVal 255,IntegerVal 127,IntegerVal 127,IntegerVal 255,IntegerVal 255,IntegerVal 21,IntegerVal 0],VectorVal [IntegerVal 187,IntegerVal 255,IntegerVal 128,IntegerVal 127,IntegerVal 255,IntegerVal 127,IntegerVal 0,IntegerVal 255,IntegerVal 128,IntegerVal 255,IntegerVal 255,IntegerVal 255,IntegerVal 255,IntegerVal 0,IntegerVal 228,IntegerVal 208]],VectorVal [IntegerVal 128,IntegerVal 127,IntegerVal 0,IntegerVal 128,IntegerVal 128,IntegerVal 0,IntegerVal 0,IntegerVal 127]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u8(UINT64_C(0x80c923c3e17fab80));
      arg2.val[0] = vcombine_u8(vcreate_u8(UINT64_C(0xffeaff7b7f7f0044)),
                                vcreate_u8(UINT64_C(0x0015ffff7f7fffff)));
      arg2.val[1] = vcombine_u8(vcreate_u8(UINT64_C(0xff007fff7f80ffbb)),
                                vcreate_u8(UINT64_C(0xd0e400ffffffff80)));
      arg3 = vcreate_u8(UINT64_C(0x7f00008080007f80));
      clear_neon_saturated();
      //  Expect: "result" = 804444c3e144ab80
      result = vqtbx2_u8(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u8(result), 0);
      exp = UINT64_C(0x804444c3e144ab80);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2249() {

{
   {
      uint8x16_t arg1;
      uint8x16x2_t arg2;
      uint8x16_t arg3;
      uint8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"tbx\", fnname = \"vqtbx2q_u8\", rettype = \"uint8x16_t\", argtypes = \"[uint8x16_t,uint8x16x2_t,uint8x16_t]\", vals = [VectorVal [IntegerVal 128,IntegerVal 0,IntegerVal 255,IntegerVal 140,IntegerVal 98,IntegerVal 255,IntegerVal 24,IntegerVal 183,IntegerVal 127,IntegerVal 255,IntegerVal 40,IntegerVal 161,IntegerVal 128,IntegerVal 27,IntegerVal 183,IntegerVal 255],ArrayVal [VectorVal [IntegerVal 128,IntegerVal 0,IntegerVal 0,IntegerVal 127,IntegerVal 127,IntegerVal 85,IntegerVal 128,IntegerVal 128,IntegerVal 255,IntegerVal 127,IntegerVal 38,IntegerVal 0,IntegerVal 0,IntegerVal 255,IntegerVal 0,IntegerVal 38],VectorVal [IntegerVal 255,IntegerVal 255,IntegerVal 214,IntegerVal 127,IntegerVal 255,IntegerVal 48,IntegerVal 128,IntegerVal 0,IntegerVal 128,IntegerVal 0,IntegerVal 128,IntegerVal 255,IntegerVal 127,IntegerVal 246,IntegerVal 255,IntegerVal 127]],VectorVal [IntegerVal 127,IntegerVal 128,IntegerVal 191,IntegerVal 66,IntegerVal 255,IntegerVal 128,IntegerVal 255,IntegerVal 0,IntegerVal 255,IntegerVal 127,IntegerVal 255,IntegerVal 128,IntegerVal 128,IntegerVal 0,IntegerVal 0,IntegerVal 127]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u8(vcreate_u8(UINT64_C(0xb718ff628cff0080)),
                         vcreate_u8(UINT64_C(0xffb71b80a128ff7f)));
      arg2.val[0] = vcombine_u8(vcreate_u8(UINT64_C(0x8080557f7f000080)),
                                vcreate_u8(UINT64_C(0x2600ff0000267fff)));
      arg2.val[1] = vcombine_u8(vcreate_u8(UINT64_C(0x008030ff7fd6ffff)),
                                vcreate_u8(UINT64_C(0x7ffff67fff800080)));
      arg3 = vcombine_u8(vcreate_u8(UINT64_C(0x00ff80ff42bf807f)),
                         vcreate_u8(UINT64_C(0x7f00008080ff7fff)));
      clear_neon_saturated();
      //  Expect: "result" = ff808080a128ff7f8018ff628cff0080
      result = vqtbx2q_u8(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 0);
         exp = UINT64_C(0x8018ff628cff0080);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 1);
         exp = UINT64_C(0xff808080a128ff7f);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2250() {

{
   {
      int8x8_t arg1;
      int8x16x2_t arg2;
      uint8x8_t arg3;
      int8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"tbx\", fnname = \"vqtbx2_s8\", rettype = \"int8x8_t\", argtypes = \"[int8x8_t,int8x16x2_t,uint8x8_t]\", vals = [VectorVal [IntegerVal 127,IntegerVal 0,IntegerVal 127,IntegerVal 0,IntegerVal 127,IntegerVal 0,IntegerVal (-128),IntegerVal 0],ArrayVal [VectorVal [IntegerVal 127,IntegerVal (-27),IntegerVal (-1),IntegerVal (-1),IntegerVal (-1),IntegerVal 127,IntegerVal 127,IntegerVal (-128),IntegerVal (-128),IntegerVal 0,IntegerVal 0,IntegerVal 127,IntegerVal (-1),IntegerVal 94,IntegerVal (-1),IntegerVal (-128)],VectorVal [IntegerVal 127,IntegerVal 0,IntegerVal (-1),IntegerVal (-1),IntegerVal (-122),IntegerVal (-128),IntegerVal (-46),IntegerVal (-128),IntegerVal (-1),IntegerVal 127,IntegerVal (-1),IntegerVal (-128),IntegerVal (-128),IntegerVal (-16),IntegerVal 0,IntegerVal (-128)]],VectorVal [IntegerVal 162,IntegerVal 0,IntegerVal 0,IntegerVal 128,IntegerVal 255,IntegerVal 128,IntegerVal 255,IntegerVal 128]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s8(UINT64_C(0x0080007f007f007f));
      arg2.val[0] = vcombine_s8(vcreate_s8(UINT64_C(0x807f7fffffffe57f)),
                                vcreate_s8(UINT64_C(0x80ff5eff7f000080)));
      arg2.val[1] = vcombine_s8(vcreate_s8(UINT64_C(0x80d28086ffff007f)),
                                vcreate_s8(UINT64_C(0x8000f08080ff7fff)));
      arg3 = vcreate_u8(UINT64_C(0x80ff80ff800000a2));
      clear_neon_saturated();
      //  Expect: "result" = 0080007f007f7f7f
      result = vqtbx2_s8(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s8(result), 0);
      exp = UINT64_C(0x0080007f007f7f7f);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2251() {

{
   {
      int8x16_t arg1;
      int8x16x2_t arg2;
      uint8x16_t arg3;
      int8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"tbx\", fnname = \"vqtbx2q_s8\", rettype = \"int8x16_t\", argtypes = \"[int8x16_t,int8x16x2_t,uint8x16_t]\", vals = [VectorVal [IntegerVal (-17),IntegerVal (-128),IntegerVal (-1),IntegerVal (-1),IntegerVal (-1),IntegerVal 0,IntegerVal 127,IntegerVal (-1),IntegerVal 27,IntegerVal (-128),IntegerVal 127,IntegerVal (-1),IntegerVal 127,IntegerVal (-1),IntegerVal (-128),IntegerVal 0],ArrayVal [VectorVal [IntegerVal (-60),IntegerVal 0,IntegerVal 127,IntegerVal 0,IntegerVal (-128),IntegerVal (-128),IntegerVal 127,IntegerVal (-1),IntegerVal 69,IntegerVal 0,IntegerVal (-128),IntegerVal (-128),IntegerVal (-1),IntegerVal 0,IntegerVal 75,IntegerVal (-122)],VectorVal [IntegerVal (-128),IntegerVal 0,IntegerVal 0,IntegerVal 0,IntegerVal (-128),IntegerVal 32,IntegerVal 0,IntegerVal (-1),IntegerVal (-111),IntegerVal 0,IntegerVal (-1),IntegerVal (-128),IntegerVal (-1),IntegerVal 0,IntegerVal (-1),IntegerVal 0]],VectorVal [IntegerVal 161,IntegerVal 127,IntegerVal 255,IntegerVal 128,IntegerVal 0,IntegerVal 70,IntegerVal 128,IntegerVal 127,IntegerVal 128,IntegerVal 21,IntegerVal 255,IntegerVal 127,IntegerVal 26,IntegerVal 0,IntegerVal 128,IntegerVal 127]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s8(vcreate_s8(UINT64_C(0xff7f00ffffff80ef)),
                         vcreate_s8(UINT64_C(0x0080ff7fff7f801b)));
      arg2.val[0] = vcombine_s8(vcreate_s8(UINT64_C(0xff7f8080007f00c4)),
                                vcreate_s8(UINT64_C(0x864b00ff80800045)));
      arg2.val[1] = vcombine_s8(vcreate_s8(UINT64_C(0xff00208000000080)),
                                vcreate_s8(UINT64_C(0x00ff00ff80ff0091)));
      arg3 = vcombine_u8(vcreate_u8(UINT64_C(0x7f80460080ff7fa1)),
                         vcreate_u8(UINT64_C(0x7f80001a7fff1580)));
      clear_neon_saturated();
      //  Expect: "result" = 0080c4ffff7f201bff7f00c4ffff80ef
      result = vqtbx2q_s8(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result), 0);
         exp = UINT64_C(0xff7f00c4ffff80ef);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result), 1);
         exp = UINT64_C(0x0080c4ffff7f201b);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2252() {

{
   {
      poly8x8_t arg1;
      poly8x16x2_t arg2;
      uint8x8_t arg3;
      poly8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"tbx\", fnname = \"vqtbx2_p8\", rettype = \"poly8x8_t\", argtypes = \"[poly8x8_t,poly8x16x2_t,uint8x8_t]\", vals = [VectorVal [PolyVal [0,0,0,0,1,0,0,0],PolyVal [0,0,0,1,0,0,1,1],PolyVal [1,0,1,0,0,0,0,0],PolyVal [0,1,0,0,1,0,0,1],PolyVal [0,1,1,0,1,1,1,1],PolyVal [1,0,0,1,1,1,0,1],PolyVal [0,0,1,0,0,1,1,1],PolyVal [0,0,0,0,1,1,1,0]],ArrayVal [VectorVal [PolyVal [1,1,1,1,1,1,0,0],PolyVal [0,1,0,1,1,0,0,0],PolyVal [0,0,0,0,1,0,0,1],PolyVal [1,0,0,0,1,0,0,0],PolyVal [1,1,0,1,0,1,0,0],PolyVal [1,1,0,0,1,1,1,0],PolyVal [1,0,1,0,0,1,1,0],PolyVal [1,0,0,1,1,1,0,0],PolyVal [0,0,0,1,0,1,1,1],PolyVal [1,0,0,0,1,1,1,0],PolyVal [0,1,0,0,1,1,0,1],PolyVal [0,1,0,0,0,0,1,0],PolyVal [1,1,1,0,0,0,1,0],PolyVal [0,1,1,1,1,0,1,0],PolyVal [0,1,0,1,1,1,1,0],PolyVal [0,1,1,1,0,1,0,0]],VectorVal [PolyVal [0,1,1,1,1,0,0,1],PolyVal [0,0,1,1,1,1,1,1],PolyVal [0,0,0,1,0,1,1,0],PolyVal [1,0,1,0,1,1,1,0],PolyVal [1,0,0,0,1,0,0,1],PolyVal [1,1,1,1,0,1,1,0],PolyVal [1,0,0,0,1,0,0,1],PolyVal [0,1,0,1,0,0,1,0],PolyVal [1,1,0,1,0,0,1,0],PolyVal [1,0,0,1,1,0,1,1],PolyVal [1,0,0,1,0,0,0,0],PolyVal [0,0,1,1,1,1,1,0],PolyVal [1,1,1,1,0,0,0,1],PolyVal [1,1,1,1,1,0,0,0],PolyVal [1,0,1,1,0,1,0,1],PolyVal [0,0,0,0,0,0,1,0]]],VectorVal [IntegerVal 127,IntegerVal 255,IntegerVal 77,IntegerVal 255,IntegerVal 127,IntegerVal 0,IntegerVal 255,IntegerVal 128]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_p8(UINT64_C(0x70e4b9f69205c810));
      arg2.val[0] = vcombine_p8(vcreate_p8(UINT64_C(0x3965732b11901a3f)),
                                vcreate_p8(UINT64_C(0x2e7a5e4742b271e8)));
      arg2.val[1] = vcombine_p8(vcreate_p8(UINT64_C(0x4a916f917568fc9e)),
                                vcreate_p8(UINT64_C(0x40ad1f8f7c09d94b)));
      arg3 = vcreate_u8(UINT64_C(0x80ff007fff4dff7f));
      clear_neon_saturated();
      //  Expect: "result" = 70e43ff69205c810
      result = vqtbx2_p8(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_p8(result), 0);
      exp = UINT64_C(0x70e43ff69205c810);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2253() {

{
   {
      poly8x16_t arg1;
      poly8x16x2_t arg2;
      uint8x16_t arg3;
      poly8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"tbx\", fnname = \"vqtbx2q_p8\", rettype = \"poly8x16_t\", argtypes = \"[poly8x16_t,poly8x16x2_t,uint8x16_t]\", vals = [VectorVal [PolyVal [1,1,0,1,1,0,0,0],PolyVal [1,1,0,0,1,0,1,0],PolyVal [1,0,1,1,0,1,1,0],PolyVal [1,1,0,0,1,0,1,1],PolyVal [1,0,0,0,1,1,0,0],PolyVal [1,0,0,0,1,1,1,0],PolyVal [1,1,1,0,1,1,1,0],PolyVal [1,1,1,1,0,1,0,0],PolyVal [1,0,1,1,0,1,0,0],PolyVal [0,1,1,0,1,1,0,0],PolyVal [0,0,1,1,0,1,0,0],PolyVal [0,1,0,1,0,1,0,0],PolyVal [0,1,0,0,0,1,0,0],PolyVal [1,1,1,0,0,1,1,1],PolyVal [0,0,1,0,0,0,1,0],PolyVal [0,0,0,1,1,1,0,0]],ArrayVal [VectorVal [PolyVal [1,1,1,0,0,1,1,0],PolyVal [0,1,0,1,0,0,1,1],PolyVal [1,0,0,1,1,1,0,1],PolyVal [0,1,0,1,0,1,1,0],PolyVal [0,0,1,1,0,0,0,1],PolyVal [0,1,1,0,0,1,1,0],PolyVal [1,0,0,1,1,0,0,1],PolyVal [1,1,1,0,1,1,1,1],PolyVal [0,1,0,1,1,1,1,1],PolyVal [1,0,1,1,1,0,0,1],PolyVal [0,0,1,1,0,1,0,0],PolyVal [1,0,0,0,1,1,1,0],PolyVal [1,1,0,0,1,1,0,1],PolyVal [0,1,1,0,0,1,0,1],PolyVal [0,1,0,1,1,0,0,1],PolyVal [1,0,1,1,1,0,1,0]],VectorVal [PolyVal [1,1,0,0,0,0,1,0],PolyVal [0,0,1,1,0,0,0,0],PolyVal [0,0,1,0,0,0,0,1],PolyVal [1,1,1,1,1,0,0,1],PolyVal [0,0,1,1,0,0,1,0],PolyVal [0,1,0,0,1,1,1,0],PolyVal [0,1,0,0,0,0,0,1],PolyVal [1,0,0,1,0,1,1,0],PolyVal [1,0,1,1,0,0,0,0],PolyVal [0,0,1,0,1,0,0,1],PolyVal [1,1,0,0,1,1,0,0],PolyVal [0,0,1,0,1,0,1,0],PolyVal [0,1,1,1,1,1,1,1],PolyVal [1,1,0,0,0,0,0,1],PolyVal [0,1,0,0,0,1,0,0],PolyVal [1,0,0,0,1,1,1,1]]],VectorVal [IntegerVal 0,IntegerVal 127,IntegerVal 127,IntegerVal 128,IntegerVal 127,IntegerVal 128,IntegerVal 127,IntegerVal 248,IntegerVal 0,IntegerVal 0,IntegerVal 127,IntegerVal 255,IntegerVal 255,IntegerVal 255,IntegerVal 0,IntegerVal 255]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_p8(vcreate_p8(UINT64_C(0x2f777131d36d531b)),
                         vcreate_p8(UINT64_C(0x3844e7222a2c362d)));
      arg2.val[0] = vcombine_p8(vcreate_p8(UINT64_C(0xf799668c6ab9ca67)),
                                vcreate_p8(UINT64_C(0x5d9aa6b3712c9dfa)));
      arg2.val[1] = vcombine_p8(vcreate_p8(UINT64_C(0x6982724c9f840c43)),
                                vcreate_p8(UINT64_C(0xf12283fe5433940d)));
      arg3 = vcombine_u8(vcreate_u8(UINT64_C(0xf87f807f807f7f00)),
                         vcreate_u8(UINT64_C(0xff00ffffff7f0000)));
      clear_neon_saturated();
      //  Expect: "result" = 3867e7222a2c67672f777131d36d5367
      result = vqtbx2q_p8(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p8(result), 0);
         exp = UINT64_C(0x2f777131d36d5367);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p8(result), 1);
         exp = UINT64_C(0x3867e7222a2c6767);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2254() {

{
   {
      uint8x8_t arg1;
      uint8x16x3_t arg2;
      uint8x8_t arg3;
      uint8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"tbx\", fnname = \"vqtbx3_u8\", rettype = \"uint8x8_t\", argtypes = \"[uint8x8_t,uint8x16x3_t,uint8x8_t]\", vals = [VectorVal [IntegerVal 128,IntegerVal 127,IntegerVal 0,IntegerVal 127,IntegerVal 255,IntegerVal 127,IntegerVal 255,IntegerVal 127],ArrayVal [VectorVal [IntegerVal 67,IntegerVal 128,IntegerVal 127,IntegerVal 127,IntegerVal 255,IntegerVal 127,IntegerVal 0,IntegerVal 255,IntegerVal 255,IntegerVal 0,IntegerVal 255,IntegerVal 128,IntegerVal 127,IntegerVal 160,IntegerVal 127,IntegerVal 196],VectorVal [IntegerVal 197,IntegerVal 127,IntegerVal 128,IntegerVal 127,IntegerVal 255,IntegerVal 255,IntegerVal 0,IntegerVal 255,IntegerVal 0,IntegerVal 0,IntegerVal 127,IntegerVal 128,IntegerVal 128,IntegerVal 128,IntegerVal 232,IntegerVal 128],VectorVal [IntegerVal 0,IntegerVal 0,IntegerVal 0,IntegerVal 5,IntegerVal 255,IntegerVal 127,IntegerVal 141,IntegerVal 0,IntegerVal 255,IntegerVal 128,IntegerVal 128,IntegerVal 128,IntegerVal 76,IntegerVal 0,IntegerVal 255,IntegerVal 127]],VectorVal [IntegerVal 0,IntegerVal 128,IntegerVal 0,IntegerVal 0,IntegerVal 255,IntegerVal 127,IntegerVal 0,IntegerVal 0]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u8(UINT64_C(0x7fff7fff7f007f80));
      arg2.val[0] = vcombine_u8(vcreate_u8(UINT64_C(0xff007fff7f7f8043)),
                                vcreate_u8(UINT64_C(0xc47fa07f80ff00ff)));
      arg2.val[1] = vcombine_u8(vcreate_u8(UINT64_C(0xff00ffff7f807fc5)),
                                vcreate_u8(UINT64_C(0x80e88080807f0000)));
      arg2.val[2] = vcombine_u8(vcreate_u8(UINT64_C(0x008d7fff05000000)),
                                vcreate_u8(UINT64_C(0x7fff004c808080ff)));
      arg3 = vcreate_u8(UINT64_C(0x00007fff00008000));
      clear_neon_saturated();
      //  Expect: "result" = 43437fff43437f43
      result = vqtbx3_u8(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u8(result), 0);
      exp = UINT64_C(0x43437fff43437f43);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2255() {

{
   {
      uint8x16_t arg1;
      uint8x16x3_t arg2;
      uint8x16_t arg3;
      uint8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"tbx\", fnname = \"vqtbx3q_u8\", rettype = \"uint8x16_t\", argtypes = \"[uint8x16_t,uint8x16x3_t,uint8x16_t]\", vals = [VectorVal [IntegerVal 127,IntegerVal 0,IntegerVal 0,IntegerVal 197,IntegerVal 0,IntegerVal 128,IntegerVal 0,IntegerVal 128,IntegerVal 159,IntegerVal 255,IntegerVal 255,IntegerVal 0,IntegerVal 0,IntegerVal 185,IntegerVal 128,IntegerVal 128],ArrayVal [VectorVal [IntegerVal 0,IntegerVal 127,IntegerVal 168,IntegerVal 127,IntegerVal 0,IntegerVal 128,IntegerVal 0,IntegerVal 128,IntegerVal 255,IntegerVal 255,IntegerVal 110,IntegerVal 255,IntegerVal 128,IntegerVal 0,IntegerVal 0,IntegerVal 0],VectorVal [IntegerVal 164,IntegerVal 255,IntegerVal 0,IntegerVal 127,IntegerVal 0,IntegerVal 0,IntegerVal 127,IntegerVal 186,IntegerVal 127,IntegerVal 0,IntegerVal 128,IntegerVal 127,IntegerVal 128,IntegerVal 255,IntegerVal 102,IntegerVal 127],VectorVal [IntegerVal 16,IntegerVal 255,IntegerVal 255,IntegerVal 0,IntegerVal 255,IntegerVal 0,IntegerVal 128,IntegerVal 128,IntegerVal 0,IntegerVal 128,IntegerVal 255,IntegerVal 127,IntegerVal 128,IntegerVal 127,IntegerVal 0,IntegerVal 127]],VectorVal [IntegerVal 127,IntegerVal 255,IntegerVal 127,IntegerVal 0,IntegerVal 77,IntegerVal 240,IntegerVal 127,IntegerVal 0,IntegerVal 255,IntegerVal 0,IntegerVal 128,IntegerVal 255,IntegerVal 202,IntegerVal 128,IntegerVal 128,IntegerVal 128]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u8(vcreate_u8(UINT64_C(0x80008000c500007f)),
                         vcreate_u8(UINT64_C(0x8080b90000ffff9f)));
      arg2.val[0] = vcombine_u8(vcreate_u8(UINT64_C(0x800080007fa87f00)),
                                vcreate_u8(UINT64_C(0x00000080ff6effff)));
      arg2.val[1] = vcombine_u8(vcreate_u8(UINT64_C(0xba7f00007f00ffa4)),
                                vcreate_u8(UINT64_C(0x7f66ff807f80007f)));
      arg2.val[2] = vcombine_u8(vcreate_u8(UINT64_C(0x808000ff00ffff10)),
                                vcreate_u8(UINT64_C(0x7f007f807fff8000)));
      arg3 = vcombine_u8(vcreate_u8(UINT64_C(0x007ff04d007fff7f)),
                         vcreate_u8(UINT64_C(0x808080caff8000ff)));
      clear_neon_saturated();
      //  Expect: "result" = 8080b90000ff009f000080000000007f
      result = vqtbx3q_u8(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 0);
         exp = UINT64_C(0x000080000000007f);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 1);
         exp = UINT64_C(0x8080b90000ff009f);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2256() {

{
   {
      int8x8_t arg1;
      int8x16x3_t arg2;
      uint8x8_t arg3;
      int8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"tbx\", fnname = \"vqtbx3_s8\", rettype = \"int8x8_t\", argtypes = \"[int8x8_t,int8x16x3_t,uint8x8_t]\", vals = [VectorVal [IntegerVal (-1),IntegerVal 127,IntegerVal 127,IntegerVal 0,IntegerVal 105,IntegerVal (-1),IntegerVal 56,IntegerVal (-64)],ArrayVal [VectorVal [IntegerVal (-128),IntegerVal 76,IntegerVal (-84),IntegerVal (-1),IntegerVal 0,IntegerVal (-1),IntegerVal (-128),IntegerVal 127,IntegerVal (-7),IntegerVal (-1),IntegerVal 127,IntegerVal 127,IntegerVal 55,IntegerVal (-45),IntegerVal (-128),IntegerVal 127],VectorVal [IntegerVal (-1),IntegerVal (-11),IntegerVal (-128),IntegerVal (-128),IntegerVal 0,IntegerVal 24,IntegerVal 127,IntegerVal 0,IntegerVal (-108),IntegerVal (-1),IntegerVal (-128),IntegerVal (-128),IntegerVal (-77),IntegerVal (-35),IntegerVal (-54),IntegerVal (-128)],VectorVal [IntegerVal 127,IntegerVal (-1),IntegerVal 127,IntegerVal (-127),IntegerVal (-128),IntegerVal (-128),IntegerVal (-128),IntegerVal 127,IntegerVal (-1),IntegerVal (-19),IntegerVal (-128),IntegerVal (-1),IntegerVal 127,IntegerVal (-32),IntegerVal (-128),IntegerVal 0]],VectorVal [IntegerVal 75,IntegerVal 36,IntegerVal 0,IntegerVal 127,IntegerVal 0,IntegerVal 127,IntegerVal 253,IntegerVal 240]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s8(UINT64_C(0xc038ff69007f7fff));
      arg2.val[0] = vcombine_s8(vcreate_s8(UINT64_C(0x7f80ff00ffac4c80)),
                                vcreate_s8(UINT64_C(0x7f80d3377f7ffff9)));
      arg2.val[1] = vcombine_s8(vcreate_s8(UINT64_C(0x007f18008080f5ff)),
                                vcreate_s8(UINT64_C(0x80caddb38080ff94)));
      arg2.val[2] = vcombine_s8(vcreate_s8(UINT64_C(0x7f808080817fff7f)),
                                vcreate_s8(UINT64_C(0x0080e07fff80edff)));
      arg3 = vcreate_u8(UINT64_C(0xf0fd7f007f00244b));
      clear_neon_saturated();
      //  Expect: "result" = c038ff80008080ff
      result = vqtbx3_s8(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s8(result), 0);
      exp = UINT64_C(0xc038ff80008080ff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2257() {

{
   {
      int8x16_t arg1;
      int8x16x3_t arg2;
      uint8x16_t arg3;
      int8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"tbx\", fnname = \"vqtbx3q_s8\", rettype = \"int8x16_t\", argtypes = \"[int8x16_t,int8x16x3_t,uint8x16_t]\", vals = [VectorVal [IntegerVal (-128),IntegerVal (-1),IntegerVal 127,IntegerVal (-128),IntegerVal (-128),IntegerVal 22,IntegerVal (-1),IntegerVal 0,IntegerVal (-128),IntegerVal 0,IntegerVal (-13),IntegerVal (-1),IntegerVal (-1),IntegerVal (-1),IntegerVal 127,IntegerVal (-33)],ArrayVal [VectorVal [IntegerVal (-1),IntegerVal 0,IntegerVal 0,IntegerVal (-1),IntegerVal 0,IntegerVal (-104),IntegerVal (-1),IntegerVal 64,IntegerVal (-1),IntegerVal 127,IntegerVal 111,IntegerVal (-128),IntegerVal 0,IntegerVal 127,IntegerVal (-1),IntegerVal 127],VectorVal [IntegerVal (-1),IntegerVal 0,IntegerVal 0,IntegerVal (-128),IntegerVal 68,IntegerVal (-128),IntegerVal (-1),IntegerVal 127,IntegerVal (-128),IntegerVal 52,IntegerVal (-21),IntegerVal 0,IntegerVal 0,IntegerVal (-128),IntegerVal 0,IntegerVal 0],VectorVal [IntegerVal 57,IntegerVal 127,IntegerVal (-128),IntegerVal 127,IntegerVal (-128),IntegerVal (-72),IntegerVal 127,IntegerVal (-1),IntegerVal 0,IntegerVal 0,IntegerVal 127,IntegerVal (-1),IntegerVal (-128),IntegerVal (-1),IntegerVal 0,IntegerVal 0]],VectorVal [IntegerVal 255,IntegerVal 0,IntegerVal 255,IntegerVal 128,IntegerVal 87,IntegerVal 0,IntegerVal 0,IntegerVal 210,IntegerVal 128,IntegerVal 127,IntegerVal 127,IntegerVal 123,IntegerVal 255,IntegerVal 128,IntegerVal 187,IntegerVal 36]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s8(vcreate_s8(UINT64_C(0x00ff1680807fff80)),
                         vcreate_s8(UINT64_C(0xdf7ffffffff30080)));
      arg2.val[0] = vcombine_s8(vcreate_s8(UINT64_C(0x40ff9800ff0000ff)),
                                vcreate_s8(UINT64_C(0x7fff7f00806f7fff)));
      arg2.val[1] = vcombine_s8(vcreate_s8(UINT64_C(0x7fff8044800000ff)),
                                vcreate_s8(UINT64_C(0x0000800000eb3480)));
      arg2.val[2] = vcombine_s8(vcreate_s8(UINT64_C(0xff7fb8807f807f39)),
                                vcreate_s8(UINT64_C(0x0000ff80ff7f0000)));
      arg3 = vcombine_u8(vcreate_u8(UINT64_C(0xd200005780ff00ff)),
                         vcreate_u8(UINT64_C(0x24bb80ff7b7f7f80)));
      clear_neon_saturated();
      //  Expect: "result" = 807ffffffff3008000ffff80807fff80
      result = vqtbx3q_s8(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result), 0);
         exp = UINT64_C(0x00ffff80807fff80);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result), 1);
         exp = UINT64_C(0x807ffffffff30080);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2258() {

{
   {
      poly8x8_t arg1;
      poly8x16x3_t arg2;
      uint8x8_t arg3;
      poly8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"tbx\", fnname = \"vqtbx3_p8\", rettype = \"poly8x8_t\", argtypes = \"[poly8x8_t,poly8x16x3_t,uint8x8_t]\", vals = [VectorVal [PolyVal [1,0,0,1,1,0,0,0],PolyVal [1,0,1,0,0,1,1,0],PolyVal [0,1,0,0,1,0,0,1],PolyVal [1,0,0,1,0,1,0,0],PolyVal [0,0,0,0,0,0,1,1],PolyVal [0,1,0,1,0,0,0,0],PolyVal [0,1,0,1,0,1,1,0],PolyVal [0,0,1,0,1,0,1,1]],ArrayVal [VectorVal [PolyVal [1,0,0,1,1,1,1,1],PolyVal [0,0,1,0,0,1,1,0],PolyVal [0,1,0,1,1,1,0,1],PolyVal [0,1,1,1,0,0,1,1],PolyVal [1,1,0,1,0,0,0,0],PolyVal [0,0,0,1,0,0,1,1],PolyVal [0,1,1,0,1,1,0,1],PolyVal [1,0,0,0,0,0,1,1],PolyVal [0,0,0,0,1,1,1,0],PolyVal [0,0,0,0,0,0,0,0],PolyVal [0,1,1,0,1,0,1,0],PolyVal [1,1,0,1,0,0,1,1],PolyVal [1,1,0,1,0,1,1,0],PolyVal [1,0,1,0,0,0,0,0],PolyVal [1,1,0,1,1,1,1,1],PolyVal [1,1,0,1,0,0,0,0]],VectorVal [PolyVal [1,0,0,1,0,0,1,1],PolyVal [1,0,1,1,0,1,1,1],PolyVal [0,1,1,1,0,0,1,1],PolyVal [0,0,0,1,1,1,0,0],PolyVal [0,0,1,0,0,0,1,1],PolyVal [1,1,1,1,0,1,1,1],PolyVal [0,0,1,0,0,1,0,0],PolyVal [0,0,1,0,1,1,0,0],PolyVal [1,1,0,0,0,1,0,0],PolyVal [0,1,1,0,1,0,1,0],PolyVal [1,1,1,1,0,1,1,0],PolyVal [0,1,1,1,1,0,1,1],PolyVal [1,1,1,1,0,0,1,0],PolyVal [1,0,1,0,1,0,0,1],PolyVal [0,0,1,0,1,0,0,1],PolyVal [1,1,0,1,1,0,1,1]],VectorVal [PolyVal [0,0,1,1,1,1,0,0],PolyVal [1,0,1,1,1,0,0,0],PolyVal [0,0,0,0,1,0,0,0],PolyVal [1,0,0,0,1,0,0,1],PolyVal [0,0,0,0,0,1,1,0],PolyVal [0,1,1,0,0,0,1,1],PolyVal [1,1,0,0,0,0,0,0],PolyVal [1,0,1,1,1,0,1,0],PolyVal [0,0,0,0,0,1,0,0],PolyVal [0,0,1,0,1,0,0,1],PolyVal [1,0,0,0,1,0,1,0],PolyVal [0,0,1,1,0,1,1,0],PolyVal [1,1,0,0,1,0,0,1],PolyVal [0,1,0,1,0,0,0,0],PolyVal [1,0,0,1,0,0,0,0],PolyVal [0,1,0,0,0,1,1,1]]],VectorVal [IntegerVal 123,IntegerVal 255,IntegerVal 127,IntegerVal 128,IntegerVal 128,IntegerVal 128,IntegerVal 255,IntegerVal 0]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_p8(UINT64_C(0xd46a0ac029926519));
      arg2.val[0] = vcombine_p8(vcreate_p8(UINT64_C(0xc1b6c80bceba64f9)),
                                vcreate_p8(UINT64_C(0x0bfb056bcb560070)));
      arg2.val[1] = vcombine_p8(vcreate_p8(UINT64_C(0x3424efc438ceedc9)),
                                vcreate_p8(UINT64_C(0xdb94954fde6f5623)));
      arg2.val[2] = vcombine_p8(vcreate_p8(UINT64_C(0x5d03c66091101d3c)),
                                vcreate_p8(UINT64_C(0xe2090a936c519420)));
      arg3 = vcreate_u8(UINT64_C(0x00ff8080807fff7b));
      clear_neon_saturated();
      //  Expect: "result" = f96a0ac029926519
      result = vqtbx3_p8(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_p8(result), 0);
      exp = UINT64_C(0xf96a0ac029926519);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2259() {

{
   {
      poly8x16_t arg1;
      poly8x16x3_t arg2;
      uint8x16_t arg3;
      poly8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"tbx\", fnname = \"vqtbx3q_p8\", rettype = \"poly8x16_t\", argtypes = \"[poly8x16_t,poly8x16x3_t,uint8x16_t]\", vals = [VectorVal [PolyVal [1,1,0,0,1,1,1,0],PolyVal [0,0,0,0,1,1,1,0],PolyVal [0,1,1,0,1,1,0,1],PolyVal [1,1,0,1,0,0,0,1],PolyVal [1,0,1,1,1,1,0,1],PolyVal [1,1,1,0,1,1,0,1],PolyVal [1,1,0,0,1,0,1,1],PolyVal [1,0,1,1,1,1,1,0],PolyVal [1,1,0,0,0,1,1,1],PolyVal [1,1,1,0,0,1,0,0],PolyVal [1,0,0,1,1,0,0,0],PolyVal [0,0,1,0,0,0,0,1],PolyVal [1,0,0,0,0,1,1,0],PolyVal [1,0,0,0,0,0,1,1],PolyVal [1,0,0,0,1,1,0,1],PolyVal [1,1,0,0,0,0,0,0]],ArrayVal [VectorVal [PolyVal [0,0,0,0,1,1,1,0],PolyVal [1,1,1,0,1,1,1,0],PolyVal [1,0,1,0,1,1,0,1],PolyVal [1,1,0,0,1,1,1,0],PolyVal [1,0,1,0,0,0,0,1],PolyVal [0,0,1,1,0,1,1,1],PolyVal [0,1,0,1,0,0,1,0],PolyVal [1,0,0,0,1,1,1,1],PolyVal [1,1,1,1,1,0,1,0],PolyVal [1,1,0,1,0,0,0,1],PolyVal [0,1,1,0,1,0,0,1],PolyVal [1,1,1,0,0,0,1,0],PolyVal [1,0,1,0,0,0,1,1],PolyVal [0,1,1,0,0,0,1,1],PolyVal [1,1,1,0,1,1,0,0],PolyVal [1,1,0,0,0,0,1,0]],VectorVal [PolyVal [1,1,0,0,0,1,0,0],PolyVal [1,0,1,1,1,0,0,0],PolyVal [0,1,1,0,0,1,0,0],PolyVal [1,0,0,0,1,1,0,0],PolyVal [1,0,0,1,1,1,0,0],PolyVal [0,0,0,0,0,0,0,0],PolyVal [1,0,0,1,0,0,1,1],PolyVal [1,1,1,1,0,1,0,0],PolyVal [0,0,1,1,1,1,1,0],PolyVal [0,1,0,0,0,0,0,1],PolyVal [1,1,0,1,1,1,1,1],PolyVal [0,0,0,1,0,1,1,1],PolyVal [0,1,1,0,0,1,1,1],PolyVal [0,1,0,1,0,1,1,1],PolyVal [0,0,0,0,0,1,1,1],PolyVal [0,0,1,0,1,0,0,0]],VectorVal [PolyVal [1,0,1,1,1,0,0,1],PolyVal [1,1,0,1,1,1,1,1],PolyVal [0,0,1,1,0,1,0,0],PolyVal [0,1,0,1,0,0,0,0],PolyVal [1,1,1,0,1,1,1,0],PolyVal [0,1,0,1,1,0,0,0],PolyVal [0,0,1,1,0,0,1,1],PolyVal [1,1,0,0,1,1,0,0],PolyVal [0,1,0,1,1,0,1,1],PolyVal [1,0,1,0,1,1,0,0],PolyVal [1,0,1,0,0,1,1,0],PolyVal [0,1,0,0,0,0,1,0],PolyVal [1,0,0,1,0,0,0,0],PolyVal [1,1,0,0,0,1,0,0],PolyVal [0,1,0,1,1,0,0,1],PolyVal [1,1,1,1,0,0,1,1]]],VectorVal [IntegerVal 0,IntegerVal 128,IntegerVal 0,IntegerVal 60,IntegerVal 179,IntegerVal 127,IntegerVal 127,IntegerVal 149,IntegerVal 127,IntegerVal 0,IntegerVal 128,IntegerVal 0,IntegerVal 27,IntegerVal 128,IntegerVal 127,IntegerVal 127]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_p8(vcreate_p8(UINT64_C(0x7dd3b7bd8bb67073)),
                         vcreate_p8(UINT64_C(0x03b1c161841927e3)));
      arg2.val[0] = vcombine_p8(vcreate_p8(UINT64_C(0xf14aec8573b57770)),
                                vcreate_p8(UINT64_C(0x4337c6c547968b5f)));
      arg2.val[1] = vcombine_p8(vcreate_p8(UINT64_C(0x2fc9003931261d23)),
                                vcreate_p8(UINT64_C(0x14e0eae6e8fb827c)));
      arg2.val[2] = vcombine_p8(vcreate_p8(UINT64_C(0x33cc1a770a2cfb9d)),
                                vcreate_p8(UINT64_C(0xcf9a2309426535da)));
      arg3 = vcombine_u8(vcreate_u8(UINT64_C(0x957f7fb33c008000)),
                         vcreate_u8(UINT64_C(0x7f7f801b0080007f)));
      clear_neon_saturated();
      //  Expect: "result" = 03b1c1e8701970e37dd3b7bd8b707070
      result = vqtbx3q_p8(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p8(result), 0);
         exp = UINT64_C(0x7dd3b7bd8b707070);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p8(result), 1);
         exp = UINT64_C(0x03b1c1e8701970e3);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2260() {

{
   {
      uint8x8_t arg1;
      uint8x16x4_t arg2;
      uint8x8_t arg3;
      uint8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"tbx\", fnname = \"vqtbx4_u8\", rettype = \"uint8x8_t\", argtypes = \"[uint8x8_t,uint8x16x4_t,uint8x8_t]\", vals = [VectorVal [IntegerVal 255,IntegerVal 110,IntegerVal 0,IntegerVal 16,IntegerVal 70,IntegerVal 127,IntegerVal 0,IntegerVal 128],ArrayVal [VectorVal [IntegerVal 128,IntegerVal 74,IntegerVal 128,IntegerVal 0,IntegerVal 128,IntegerVal 0,IntegerVal 128,IntegerVal 255,IntegerVal 255,IntegerVal 255,IntegerVal 182,IntegerVal 255,IntegerVal 142,IntegerVal 128,IntegerVal 0,IntegerVal 128],VectorVal [IntegerVal 128,IntegerVal 128,IntegerVal 255,IntegerVal 255,IntegerVal 128,IntegerVal 128,IntegerVal 128,IntegerVal 127,IntegerVal 255,IntegerVal 0,IntegerVal 127,IntegerVal 127,IntegerVal 255,IntegerVal 128,IntegerVal 255,IntegerVal 0],VectorVal [IntegerVal 127,IntegerVal 225,IntegerVal 163,IntegerVal 127,IntegerVal 127,IntegerVal 128,IntegerVal 128,IntegerVal 0,IntegerVal 0,IntegerVal 128,IntegerVal 128,IntegerVal 255,IntegerVal 23,IntegerVal 114,IntegerVal 127,IntegerVal 255],VectorVal [IntegerVal 255,IntegerVal 3,IntegerVal 127,IntegerVal 128,IntegerVal 93,IntegerVal 0,IntegerVal 127,IntegerVal 127,IntegerVal 128,IntegerVal 127,IntegerVal 255,IntegerVal 75,IntegerVal 255,IntegerVal 255,IntegerVal 127,IntegerVal 212]],VectorVal [IntegerVal 0,IntegerVal 62,IntegerVal 221,IntegerVal 127,IntegerVal 127,IntegerVal 0,IntegerVal 218,IntegerVal 255]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u8(UINT64_C(0x80007f4610006eff));
      arg2.val[0] = vcombine_u8(vcreate_u8(UINT64_C(0xff80008000804a80)),
                                vcreate_u8(UINT64_C(0x8000808effb6ffff)));
      arg2.val[1] = vcombine_u8(vcreate_u8(UINT64_C(0x7f808080ffff8080)),
                                vcreate_u8(UINT64_C(0x00ff80ff7f7f00ff)));
      arg2.val[2] = vcombine_u8(vcreate_u8(UINT64_C(0x0080807f7fa3e17f)),
                                vcreate_u8(UINT64_C(0xff7f7217ff808000)));
      arg2.val[3] = vcombine_u8(vcreate_u8(UINT64_C(0x7f7f005d807f03ff)),
                                vcreate_u8(UINT64_C(0xd47fffff4bff7f80)));
      arg3 = vcreate_u8(UINT64_C(0xffda007f7fdd3e00));
      clear_neon_saturated();
      //  Expect: "result" = 8000804610007f80
      result = vqtbx4_u8(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u8(result), 0);
      exp = UINT64_C(0x8000804610007f80);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2261() {

{
   {
      uint8x16_t arg1;
      uint8x16x4_t arg2;
      uint8x16_t arg3;
      uint8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"tbx\", fnname = \"vqtbx4q_u8\", rettype = \"uint8x16_t\", argtypes = \"[uint8x16_t,uint8x16x4_t,uint8x16_t]\", vals = [VectorVal [IntegerVal 128,IntegerVal 128,IntegerVal 127,IntegerVal 127,IntegerVal 128,IntegerVal 255,IntegerVal 127,IntegerVal 128,IntegerVal 127,IntegerVal 127,IntegerVal 83,IntegerVal 128,IntegerVal 128,IntegerVal 127,IntegerVal 41,IntegerVal 0],ArrayVal [VectorVal [IntegerVal 128,IntegerVal 0,IntegerVal 127,IntegerVal 21,IntegerVal 255,IntegerVal 199,IntegerVal 255,IntegerVal 127,IntegerVal 0,IntegerVal 127,IntegerVal 128,IntegerVal 0,IntegerVal 127,IntegerVal 0,IntegerVal 128,IntegerVal 127],VectorVal [IntegerVal 0,IntegerVal 127,IntegerVal 38,IntegerVal 127,IntegerVal 127,IntegerVal 255,IntegerVal 255,IntegerVal 0,IntegerVal 127,IntegerVal 221,IntegerVal 255,IntegerVal 127,IntegerVal 128,IntegerVal 128,IntegerVal 0,IntegerVal 127],VectorVal [IntegerVal 255,IntegerVal 253,IntegerVal 128,IntegerVal 0,IntegerVal 31,IntegerVal 127,IntegerVal 255,IntegerVal 0,IntegerVal 127,IntegerVal 0,IntegerVal 255,IntegerVal 128,IntegerVal 255,IntegerVal 127,IntegerVal 128,IntegerVal 127],VectorVal [IntegerVal 25,IntegerVal 89,IntegerVal 127,IntegerVal 142,IntegerVal 127,IntegerVal 127,IntegerVal 128,IntegerVal 255,IntegerVal 128,IntegerVal 127,IntegerVal 0,IntegerVal 255,IntegerVal 0,IntegerVal 255,IntegerVal 0,IntegerVal 241]],VectorVal [IntegerVal 128,IntegerVal 128,IntegerVal 127,IntegerVal 128,IntegerVal 127,IntegerVal 127,IntegerVal 58,IntegerVal 128,IntegerVal 210,IntegerVal 128,IntegerVal 255,IntegerVal 0,IntegerVal 244,IntegerVal 255,IntegerVal 128,IntegerVal 200]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u8(vcreate_u8(UINT64_C(0x807fff807f7f8080)),
                         vcreate_u8(UINT64_C(0x00297f8080537f7f)));
      arg2.val[0] = vcombine_u8(vcreate_u8(UINT64_C(0x7fffc7ff157f0080)),
                                vcreate_u8(UINT64_C(0x7f80007f00807f00)));
      arg2.val[1] = vcombine_u8(vcreate_u8(UINT64_C(0x00ffff7f7f267f00)),
                                vcreate_u8(UINT64_C(0x7f0080807fffdd7f)));
      arg2.val[2] = vcombine_u8(vcreate_u8(UINT64_C(0x00ff7f1f0080fdff)),
                                vcreate_u8(UINT64_C(0x7f807fff80ff007f)));
      arg2.val[3] = vcombine_u8(vcreate_u8(UINT64_C(0xff807f7f8e7f5919)),
                                vcreate_u8(UINT64_C(0xf100ff00ff007f80)));
      arg3 = vcombine_u8(vcreate_u8(UINT64_C(0x803a7f7f807f8080)),
                         vcreate_u8(UINT64_C(0xc880fff400ff80d2)));
      clear_neon_saturated();
      //  Expect: "result" = 00297f8080537f7f8000ff807f7f8080
      result = vqtbx4q_u8(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 0);
         exp = UINT64_C(0x8000ff807f7f8080);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 1);
         exp = UINT64_C(0x00297f8080537f7f);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2262() {

{
   {
      int8x8_t arg1;
      int8x16x4_t arg2;
      uint8x8_t arg3;
      int8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"tbx\", fnname = \"vqtbx4_s8\", rettype = \"int8x8_t\", argtypes = \"[int8x8_t,int8x16x4_t,uint8x8_t]\", vals = [VectorVal [IntegerVal 127,IntegerVal 127,IntegerVal 39,IntegerVal (-83),IntegerVal 127,IntegerVal (-128),IntegerVal (-128),IntegerVal (-128)],ArrayVal [VectorVal [IntegerVal 127,IntegerVal (-123),IntegerVal 127,IntegerVal (-82),IntegerVal (-1),IntegerVal (-1),IntegerVal (-1),IntegerVal 127,IntegerVal (-87),IntegerVal 31,IntegerVal (-27),IntegerVal (-1),IntegerVal (-81),IntegerVal (-128),IntegerVal (-128),IntegerVal (-128)],VectorVal [IntegerVal (-128),IntegerVal 0,IntegerVal 127,IntegerVal 49,IntegerVal (-1),IntegerVal (-128),IntegerVal 127,IntegerVal 0,IntegerVal 0,IntegerVal 127,IntegerVal 98,IntegerVal (-1),IntegerVal 0,IntegerVal 127,IntegerVal 127,IntegerVal 25],VectorVal [IntegerVal 116,IntegerVal 41,IntegerVal 127,IntegerVal 127,IntegerVal (-1),IntegerVal 0,IntegerVal 0,IntegerVal 0,IntegerVal (-111),IntegerVal 127,IntegerVal (-60),IntegerVal (-1),IntegerVal 127,IntegerVal (-128),IntegerVal (-128),IntegerVal (-125)],VectorVal [IntegerVal (-71),IntegerVal (-1),IntegerVal 63,IntegerVal (-128),IntegerVal (-1),IntegerVal (-1),IntegerVal 127,IntegerVal 0,IntegerVal (-128),IntegerVal 0,IntegerVal (-128),IntegerVal (-128),IntegerVal (-128),IntegerVal 127,IntegerVal 0,IntegerVal 0]],VectorVal [IntegerVal 128,IntegerVal 255,IntegerVal 255,IntegerVal 128,IntegerVal 128,IntegerVal 255,IntegerVal 0,IntegerVal 127]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s8(UINT64_C(0x8080807fad277f7f));
      arg2.val[0] = vcombine_s8(vcreate_s8(UINT64_C(0x7fffffffae7f857f)),
                                vcreate_s8(UINT64_C(0x808080afffe51fa9)));
      arg2.val[1] = vcombine_s8(vcreate_s8(UINT64_C(0x007f80ff317f0080)),
                                vcreate_s8(UINT64_C(0x197f7f00ff627f00)));
      arg2.val[2] = vcombine_s8(vcreate_s8(UINT64_C(0x000000ff7f7f2974)),
                                vcreate_s8(UINT64_C(0x8380807fffc47f91)));
      arg2.val[3] = vcombine_s8(vcreate_s8(UINT64_C(0x007fffff803fffb9)),
                                vcreate_s8(UINT64_C(0x00007f8080800080)));
      arg3 = vcreate_u8(UINT64_C(0x7f00ff8080ffff80));
      clear_neon_saturated();
      //  Expect: "result" = 807f807fad277f7f
      result = vqtbx4_s8(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s8(result), 0);
      exp = UINT64_C(0x807f807fad277f7f);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2263() {

{
   {
      int8x16_t arg1;
      int8x16x4_t arg2;
      uint8x16_t arg3;
      int8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"tbx\", fnname = \"vqtbx4q_s8\", rettype = \"int8x16_t\", argtypes = \"[int8x16_t,int8x16x4_t,uint8x16_t]\", vals = [VectorVal [IntegerVal (-1),IntegerVal (-1),IntegerVal (-1),IntegerVal (-128),IntegerVal (-128),IntegerVal (-128),IntegerVal (-128),IntegerVal 0,IntegerVal 0,IntegerVal 127,IntegerVal 127,IntegerVal (-128),IntegerVal (-128),IntegerVal (-1),IntegerVal (-128),IntegerVal 127],ArrayVal [VectorVal [IntegerVal (-1),IntegerVal 21,IntegerVal 127,IntegerVal (-1),IntegerVal (-1),IntegerVal (-1),IntegerVal 127,IntegerVal (-1),IntegerVal (-1),IntegerVal (-1),IntegerVal (-1),IntegerVal 0,IntegerVal 127,IntegerVal (-5),IntegerVal 0,IntegerVal 127],VectorVal [IntegerVal 0,IntegerVal (-1),IntegerVal (-1),IntegerVal 127,IntegerVal 127,IntegerVal 127,IntegerVal (-1),IntegerVal (-128),IntegerVal (-128),IntegerVal (-1),IntegerVal 0,IntegerVal (-1),IntegerVal (-1),IntegerVal 0,IntegerVal 0,IntegerVal 25],VectorVal [IntegerVal 127,IntegerVal 41,IntegerVal 0,IntegerVal (-80),IntegerVal (-1),IntegerVal 127,IntegerVal (-1),IntegerVal 0,IntegerVal 0,IntegerVal (-1),IntegerVal 127,IntegerVal 127,IntegerVal 127,IntegerVal (-128),IntegerVal (-128),IntegerVal (-128)],VectorVal [IntegerVal (-1),IntegerVal (-128),IntegerVal (-1),IntegerVal (-1),IntegerVal 98,IntegerVal 4,IntegerVal 0,IntegerVal 8,IntegerVal (-111),IntegerVal 0,IntegerVal (-1),IntegerVal 127,IntegerVal 0,IntegerVal (-43),IntegerVal 0,IntegerVal 0]],VectorVal [IntegerVal 81,IntegerVal 127,IntegerVal 58,IntegerVal 0,IntegerVal 127,IntegerVal 155,IntegerVal 0,IntegerVal 0,IntegerVal 127,IntegerVal 0,IntegerVal 0,IntegerVal 0,IntegerVal 255,IntegerVal 255,IntegerVal 112,IntegerVal 128]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s8(vcreate_s8(UINT64_C(0x0080808080ffffff)),
                         vcreate_s8(UINT64_C(0x7f80ff80807f7f00)));
      arg2.val[0] = vcombine_s8(vcreate_s8(UINT64_C(0xff7fffffff7f15ff)),
                                vcreate_s8(UINT64_C(0x7f00fb7f00ffffff)));
      arg2.val[1] = vcombine_s8(vcreate_s8(UINT64_C(0x80ff7f7f7fffff00)),
                                vcreate_s8(UINT64_C(0x190000ffff00ff80)));
      arg2.val[2] = vcombine_s8(vcreate_s8(UINT64_C(0x00ff7fffb000297f)),
                                vcreate_s8(UINT64_C(0x8080807f7f7fff00)));
      arg2.val[3] = vcombine_s8(vcreate_s8(UINT64_C(0x08000462ffff80ff)),
                                vcreate_s8(UINT64_C(0x0000d5007fff0091)));
      arg3 = vcombine_u8(vcreate_u8(UINT64_C(0x00009b7f003a7f51)),
                         vcreate_u8(UINT64_C(0x8070ffff0000007f)));
      clear_neon_saturated();
      //  Expect: "result" = 7f80ff80ffffff00ffff8080ffffffff
      result = vqtbx4q_s8(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result), 0);
         exp = UINT64_C(0xffff8080ffffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result), 1);
         exp = UINT64_C(0x7f80ff80ffffff00);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2264() {

{
   {
      poly8x8_t arg1;
      poly8x16x4_t arg2;
      uint8x8_t arg3;
      poly8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"tbx\", fnname = \"vqtbx4_p8\", rettype = \"poly8x8_t\", argtypes = \"[poly8x8_t,poly8x16x4_t,uint8x8_t]\", vals = [VectorVal [PolyVal [1,0,0,0,1,0,1,1],PolyVal [0,0,1,1,1,0,0,0],PolyVal [1,1,0,1,1,0,1,1],PolyVal [1,0,0,1,1,1,1,0],PolyVal [0,0,1,0,0,0,0,1],PolyVal [1,0,0,0,1,0,1,1],PolyVal [0,1,0,0,0,0,0,1],PolyVal [1,0,1,1,0,0,1,0]],ArrayVal [VectorVal [PolyVal [0,0,1,0,1,0,0,1],PolyVal [1,1,1,0,0,0,1,1],PolyVal [0,0,1,1,0,0,1,1],PolyVal [1,1,0,1,1,1,0,0],PolyVal [1,0,0,0,1,0,0,1],PolyVal [1,1,0,0,1,1,0,0],PolyVal [1,0,0,0,0,0,1,1],PolyVal [1,0,1,1,1,1,1,1],PolyVal [0,1,1,0,1,0,0,1],PolyVal [0,0,0,1,1,1,0,0],PolyVal [1,0,0,1,1,0,1,0],PolyVal [0,0,1,0,1,1,0,0],PolyVal [1,0,0,0,1,1,1,0],PolyVal [1,1,1,0,1,0,0,1],PolyVal [1,0,0,0,0,0,1,1],PolyVal [0,1,1,0,1,0,1,0]],VectorVal [PolyVal [0,0,0,0,0,1,1,1],PolyVal [0,0,0,0,1,1,1,0],PolyVal [1,1,0,1,1,1,0,1],PolyVal [0,0,1,0,1,0,1,0],PolyVal [1,0,1,1,0,0,0,0],PolyVal [0,0,0,1,1,1,1,1],PolyVal [1,0,0,0,1,1,0,0],PolyVal [0,1,1,0,0,0,1,0],PolyVal [0,1,1,1,1,1,1,0],PolyVal [1,1,1,1,0,1,0,0],PolyVal [1,0,1,1,1,0,1,1],PolyVal [1,1,1,0,1,0,0,0],PolyVal [1,1,1,1,0,1,0,0],PolyVal [0,1,0,1,1,0,0,1],PolyVal [1,1,1,0,0,0,1,1],PolyVal [1,1,1,1,1,1,1,0]],VectorVal [PolyVal [1,1,1,0,0,0,0,0],PolyVal [0,0,0,1,0,1,1,1],PolyVal [0,1,0,1,0,1,1,0],PolyVal [0,0,0,0,0,0,1,0],PolyVal [1,1,0,0,1,0,0,0],PolyVal [1,1,1,1,1,1,1,0],PolyVal [0,1,0,1,1,0,1,1],PolyVal [1,1,1,1,0,0,1,1],PolyVal [1,1,1,1,0,1,0,0],PolyVal [1,0,0,1,0,0,0,1],PolyVal [0,0,1,1,1,0,0,0],PolyVal [1,1,1,1,1,1,0,0],PolyVal [0,0,0,0,1,0,0,1],PolyVal [1,0,0,0,0,0,0,0],PolyVal [0,0,0,1,1,1,1,1],PolyVal [0,0,1,1,1,0,1,0]],VectorVal [PolyVal [0,0,0,0,1,1,0,0],PolyVal [0,0,1,1,0,0,0,1],PolyVal [0,1,1,1,0,1,0,0],PolyVal [1,1,0,1,1,1,1,0],PolyVal [1,0,0,1,0,0,1,0],PolyVal [1,0,0,0,1,0,1,1],PolyVal [0,0,0,1,1,1,1,1],PolyVal [1,1,1,1,1,0,1,0],PolyVal [0,0,1,0,0,1,0,1],PolyVal [0,0,0,0,0,0,1,0],PolyVal [1,1,1,0,0,0,0,1],PolyVal [0,0,0,0,1,0,1,1],PolyVal [1,0,0,0,0,1,0,1],PolyVal [0,1,0,1,1,0,1,0],PolyVal [0,1,1,1,1,1,0,1],PolyVal [1,0,0,1,1,0,1,0]]],VectorVal [IntegerVal 127,IntegerVal 20,IntegerVal 255,IntegerVal 127,IntegerVal 245,IntegerVal 128,IntegerVal 127,IntegerVal 255]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_p8(UINT64_C(0x4d82d18479db1cd1));
      arg2.val[0] = vcombine_p8(vcreate_p8(UINT64_C(0xfdc133913bccc794)),
                                vcreate_p8(UINT64_C(0x56c1977134593896)));
      arg2.val[1] = vcombine_p8(vcreate_p8(UINT64_C(0x4631f80d54bb70e0)),
                                vcreate_p8(UINT64_C(0x7fc79a2f17dd2f7e)));
      arg2.val[2] = vcombine_p8(vcreate_p8(UINT64_C(0xcfda7f13406ae807)),
                                vcreate_p8(UINT64_C(0x5cf801903f1c892f)));
      arg2.val[3] = vcombine_p8(vcreate_p8(UINT64_C(0x5ff8d1497b2e8c30)),
                                vcreate_p8(UINT64_C(0x59be5aa1d08740a4)));
      arg3 = vcreate_u8(UINT64_C(0xff7f80f57fff147f));
      clear_neon_saturated();
      //  Expect: "result" = 4d82d18479db0dd1
      result = vqtbx4_p8(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_p8(result), 0);
      exp = UINT64_C(0x4d82d18479db0dd1);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2265() {

{
   {
      poly8x16_t arg1;
      poly8x16x4_t arg2;
      uint8x16_t arg3;
      poly8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"tbx\", fnname = \"vqtbx4q_p8\", rettype = \"poly8x16_t\", argtypes = \"[poly8x16_t,poly8x16x4_t,uint8x16_t]\", vals = [VectorVal [PolyVal [0,1,1,0,1,0,1,1],PolyVal [1,1,1,0,1,0,1,0],PolyVal [1,1,0,1,0,1,0,1],PolyVal [0,0,1,1,1,0,0,0],PolyVal [1,0,1,0,1,0,0,1],PolyVal [0,0,1,0,1,0,1,0],PolyVal [1,1,0,0,1,0,1,1],PolyVal [0,1,1,0,0,0,1,1],PolyVal [1,0,1,1,1,1,0,1],PolyVal [0,0,1,1,0,0,0,0],PolyVal [0,1,1,1,1,0,0,0],PolyVal [0,1,1,0,0,0,0,0],PolyVal [0,0,1,1,0,0,0,1],PolyVal [0,1,1,0,0,0,0,0],PolyVal [0,1,0,1,0,1,1,1],PolyVal [1,0,1,0,1,1,0,0]],ArrayVal [VectorVal [PolyVal [1,0,0,0,0,1,1,0],PolyVal [0,0,0,0,0,1,1,1],PolyVal [1,0,0,0,1,0,0,0],PolyVal [1,0,1,0,0,1,1,0],PolyVal [1,1,1,1,1,0,0,1],PolyVal [0,1,0,1,1,0,1,0],PolyVal [0,0,0,1,0,0,1,0],PolyVal [0,0,0,1,1,1,0,0],PolyVal [0,0,1,0,1,0,0,1],PolyVal [1,0,0,0,0,1,0,0],PolyVal [1,1,0,0,0,0,1,1],PolyVal [0,0,1,0,0,1,1,1],PolyVal [1,0,1,1,0,0,0,0],PolyVal [1,0,1,0,0,1,0,1],PolyVal [1,0,0,0,1,1,0,1],PolyVal [1,1,1,0,1,0,0,1]],VectorVal [PolyVal [1,0,1,0,0,1,1,0],PolyVal [0,1,1,1,0,0,1,1],PolyVal [1,0,1,1,1,0,1,1],PolyVal [1,1,0,0,1,0,1,0],PolyVal [0,0,1,0,1,1,1,0],PolyVal [1,0,0,0,0,1,1,1],PolyVal [0,0,1,1,1,1,1,0],PolyVal [0,0,0,0,1,0,0,1],PolyVal [0,1,0,1,1,0,0,1],PolyVal [1,0,0,1,0,1,0,0],PolyVal [0,0,1,1,1,1,0,1],PolyVal [1,1,1,0,1,1,1,0],PolyVal [1,0,0,0,0,1,1,0],PolyVal [0,0,0,0,0,0,0,1],PolyVal [0,1,0,1,1,1,0,1],PolyVal [1,0,1,0,0,0,0,0]],VectorVal [PolyVal [1,1,1,0,1,0,0,0],PolyVal [1,0,1,1,1,0,0,0],PolyVal [1,0,0,1,1,1,0,1],PolyVal [0,1,0,0,0,0,1,0],PolyVal [0,0,1,0,0,0,1,0],PolyVal [0,1,0,1,1,0,1,1],PolyVal [1,1,1,1,0,1,0,1],PolyVal [0,1,1,1,1,0,1,1],PolyVal [0,0,0,0,0,1,0,0],PolyVal [1,1,0,1,0,0,1,1],PolyVal [1,1,0,0,0,0,0,0],PolyVal [0,0,1,1,1,0,0,0],PolyVal [0,0,1,1,1,1,0,1],PolyVal [1,1,1,0,0,0,0,1],PolyVal [1,1,1,0,1,0,1,0],PolyVal [1,1,1,1,0,0,1,1]],VectorVal [PolyVal [0,1,1,1,0,1,1,0],PolyVal [0,1,0,1,0,0,0,0],PolyVal [0,0,0,0,0,0,1,0],PolyVal [1,1,0,1,0,0,1,1],PolyVal [1,1,1,1,1,0,1,1],PolyVal [0,0,0,0,0,0,0,0],PolyVal [1,1,0,0,0,1,0,1],PolyVal [1,0,0,1,1,0,0,0],PolyVal [1,1,1,0,1,1,0,0],PolyVal [1,1,0,0,1,0,0,1],PolyVal [1,1,0,1,0,1,1,1],PolyVal [0,1,1,1,0,1,0,1],PolyVal [1,0,1,1,0,0,1,0],PolyVal [0,1,0,0,0,0,0,0],PolyVal [1,1,0,1,1,1,0,1],PolyVal [0,0,1,0,0,0,1,1]]],VectorVal [IntegerVal 128,IntegerVal 128,IntegerVal 128,IntegerVal 127,IntegerVal 0,IntegerVal 127,IntegerVal 255,IntegerVal 0,IntegerVal 127,IntegerVal 0,IntegerVal 255,IntegerVal 0,IntegerVal 127,IntegerVal 128,IntegerVal 158,IntegerVal 128]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_p8(vcreate_p8(UINT64_C(0xc6d354951cab57d6)),
                         vcreate_p8(UINT64_C(0x35ea068c061e0cbd)));
      arg2.val[0] = vcombine_p8(vcreate_p8(UINT64_C(0x38485a9f6511e061)),
                                vcreate_p8(UINT64_C(0x97b1a50de4c32194)));
      arg2.val[1] = vcombine_p8(vcreate_p8(UINT64_C(0x907ce17453ddce65)),
                                vcreate_p8(UINT64_C(0x05ba806177bc299a)));
      arg2.val[2] = vcombine_p8(vcreate_p8(UINT64_C(0xdeafda4442b91d17)),
                                vcreate_p8(UINT64_C(0xcf5787bc1c03cb20)));
      arg2.val[3] = vcombine_p8(vcreate_p8(UINT64_C(0x19a300dfcb400a6e)),
                                vcreate_p8(UINT64_C(0xc4bb024daeeb9337)));
      arg3 = vcombine_u8(vcreate_u8(UINT64_C(0x00ff7f007f808080)),
                         vcreate_u8(UINT64_C(0x809e807f00ff007f)));
      clear_neon_saturated();
      //  Expect: "result" = 35ea068c611e61bd61d354611cab57d6
      result = vqtbx4q_p8(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p8(result), 0);
         exp = UINT64_C(0x61d354611cab57d6);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p8(result), 1);
         exp = UINT64_C(0x35ea068c611e61bd);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2266() {

{
   {
      int16x4_t arg1;
      int16x4_t arg2;
      int16_t arg3;
      int16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"mla\", fnname = \"vmla_n_s16\", rettype = \"int16x4_t\", argtypes = \"[int16x4_t,int16x4_t,int16_t]\", vals = [VectorVal [IntegerVal 32767,IntegerVal (-1),IntegerVal 32767,IntegerVal 32767],VectorVal [IntegerVal 0,IntegerVal (-20464),IntegerVal (-1),IntegerVal (-32768)],IntegerVal 0], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s16(UINT64_C(0x7fff7fffffff7fff));
      arg2 = vcreate_s16(UINT64_C(0x8000ffffb0100000));
      arg3 = 0;
      clear_neon_saturated();
      //  Expect: "result" = 7fff7fffffff7fff
      result = vmla_n_s16(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s16(result), 0);
      exp = UINT64_C(0x7fff7fffffff7fff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2267() {

{
   {
      int32x2_t arg1;
      int32x2_t arg2;
      int32_t arg3;
      int32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"mla\", fnname = \"vmla_n_s32\", rettype = \"int32x2_t\", argtypes = \"[int32x2_t,int32x2_t,int32_t]\", vals = [VectorVal [IntegerVal (-2147418113),IntegerVal 2147418112],VectorVal [IntegerVal 32767,IntegerVal 1635319807],IntegerVal 14126], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s32(UINT64_C(0x7fff00008000ffff));
      arg2 = vcreate_s32(UINT64_C(0x6178ffff00007fff));
      arg3 = 14126;
      clear_neon_saturated();
      //  Expect: "result" = 02bcc8d29b97c8d1
      result = vmla_n_s32(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s32(result), 0);
      exp = UINT64_C(0x02bcc8d29b97c8d1);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2268() {

{
   {
      uint16x4_t arg1;
      uint16x4_t arg2;
      uint16_t arg3;
      uint16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"mla\", fnname = \"vmla_n_u16\", rettype = \"uint16x4_t\", argtypes = \"[uint16x4_t,uint16x4_t,uint16_t]\", vals = [VectorVal [IntegerVal 0,IntegerVal 0,IntegerVal 31519,IntegerVal 60430],VectorVal [IntegerVal 0,IntegerVal 0,IntegerVal 27858,IntegerVal 23260],IntegerVal 65535], start_saturated = True}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u16(UINT64_C(0xec0e7b1f00000000));
      arg2 = vcreate_u16(UINT64_C(0x5adc6cd200000000));
      arg3 = 65535U;
      set_neon_saturated();
      //  Expect: "result" = 91320e4d00000000
      result = vmla_n_u16(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u16(result), 0);
      exp = UINT64_C(0x91320e4d00000000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2269() {

{
   {
      uint32x2_t arg1;
      uint32x2_t arg2;
      uint32_t arg3;
      uint32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"mla\", fnname = \"vmla_n_u32\", rettype = \"uint32x2_t\", argtypes = \"[uint32x2_t,uint32x2_t,uint32_t]\", vals = [VectorVal [IntegerVal 2147483648,IntegerVal 4294934527],VectorVal [IntegerVal 1384284159,IntegerVal 1217834442],IntegerVal 2649325567], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u32(UINT64_C(0xffff7fff80000000));
      arg2 = vcreate_u32(UINT64_C(0x4896adca52827fff));
      arg3 = 2649325567U;
      clear_neon_saturated();
      //  Expect: "result" = 1d27d2354f940001
      result = vmla_n_u32(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u32(result), 0);
      exp = UINT64_C(0x1d27d2354f940001);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2270() {

{
   {
      int16x8_t arg1;
      int16x8_t arg2;
      int16_t arg3;
      int16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"mla\", fnname = \"vmlaq_n_s16\", rettype = \"int16x8_t\", argtypes = \"[int16x8_t,int16x8_t,int16_t]\", vals = [VectorVal [IntegerVal (-32768),IntegerVal 0,IntegerVal (-1),IntegerVal 0,IntegerVal 0,IntegerVal (-32768),IntegerVal 0,IntegerVal (-32768)],VectorVal [IntegerVal 0,IntegerVal (-1),IntegerVal (-32768),IntegerVal (-32768),IntegerVal 32767,IntegerVal 20970,IntegerVal 0,IntegerVal 0],IntegerVal 0], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s16(vcreate_s16(UINT64_C(0x0000ffff00008000)),
                          vcreate_s16(UINT64_C(0x8000000080000000)));
      arg2 = vcombine_s16(vcreate_s16(UINT64_C(0x80008000ffff0000)),
                          vcreate_s16(UINT64_C(0x0000000051ea7fff)));
      arg3 = 0;
      clear_neon_saturated();
      //  Expect: "result" = 80000000800000000000ffff00008000
      result = vmlaq_n_s16(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 0);
         exp = UINT64_C(0x0000ffff00008000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 1);
         exp = UINT64_C(0x8000000080000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2271() {

{
   {
      int32x4_t arg1;
      int32x4_t arg2;
      int32_t arg3;
      int32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"mla\", fnname = \"vmlaq_n_s32\", rettype = \"int32x4_t\", argtypes = \"[int32x4_t,int32x4_t,int32_t]\", vals = [VectorVal [IntegerVal 2147450879,IntegerVal 0,IntegerVal (-887062528),IntegerVal (-32768)],VectorVal [IntegerVal (-2072641537),IntegerVal (-65219),IntegerVal 2147450879,IntegerVal 2147450880],IntegerVal 2147483647], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s32(vcreate_s32(UINT64_C(0x000000007fff7fff)),
                          vcreate_s32(UINT64_C(0xffff8000cb208000)));
      arg2 = vcombine_s32(vcreate_s32(UINT64_C(0xffff013d8475ffff)),
                          vcreate_s32(UINT64_C(0x7fff80007fff7fff)));
      arg3 = 2147483647;
      clear_neon_saturated();
      //  Expect: "result" = 80000000cb2100018000fec37b898000
      result = vmlaq_n_s32(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 0);
         exp = UINT64_C(0x8000fec37b898000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 1);
         exp = UINT64_C(0x80000000cb210001);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2272() {

{
   {
      uint16x8_t arg1;
      uint16x8_t arg2;
      uint16_t arg3;
      uint16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"mla\", fnname = \"vmlaq_n_u16\", rettype = \"uint16x8_t\", argtypes = \"[uint16x8_t,uint16x8_t,uint16_t]\", vals = [VectorVal [IntegerVal 22834,IntegerVal 51860,IntegerVal 32767,IntegerVal 32768,IntegerVal 0,IntegerVal 65535,IntegerVal 65535,IntegerVal 32767],VectorVal [IntegerVal 9921,IntegerVal 0,IntegerVal 65535,IntegerVal 65535,IntegerVal 32767,IntegerVal 32768,IntegerVal 32767,IntegerVal 0],IntegerVal 32767], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u16(vcreate_u16(UINT64_C(0x80007fffca945932)),
                          vcreate_u16(UINT64_C(0x7fffffffffff0000)));
      arg2 = vcombine_u16(vcreate_u16(UINT64_C(0xffffffff000026c1)),
                          vcreate_u16(UINT64_C(0x00007fff80007fff)));
      arg3 = 32767U;
      clear_neon_saturated();
      //  Expect: "result" = 7fff00007fff000100010000ca94b271
      result = vmlaq_n_u16(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 0);
         exp = UINT64_C(0x00010000ca94b271);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 1);
         exp = UINT64_C(0x7fff00007fff0001);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2273() {

{
   {
      uint32x4_t arg1;
      uint32x4_t arg2;
      uint32_t arg3;
      uint32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"mla\", fnname = \"vmlaq_n_u32\", rettype = \"uint32x4_t\", argtypes = \"[uint32x4_t,uint32x4_t,uint32_t]\", vals = [VectorVal [IntegerVal 2147479354,IntegerVal 2147450880,IntegerVal 0,IntegerVal 0],VectorVal [IntegerVal 0,IntegerVal 2147516416,IntegerVal 65535,IntegerVal 4294934528],IntegerVal 32768], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u32(vcreate_u32(UINT64_C(0x7fff80007fffef3a)),
                          vcreate_u32(0));
      arg2 = vcombine_u32(vcreate_u32(UINT64_C(0x8000800000000000)),
                          vcreate_u32(UINT64_C(0xffff80000000ffff)));
      arg3 = 32768U;
      clear_neon_saturated();
      //  Expect: "result" = c00000007fff8000bfff80007fffef3a
      result = vmlaq_n_u32(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 0);
         exp = UINT64_C(0xbfff80007fffef3a);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 1);
         exp = UINT64_C(0xc00000007fff8000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2274() {

{
   {
      float32x2_t arg1;
      float32x2_t arg2;
      float32_t arg3;
      float32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"mla\", fnname = \"vfma_n_f32\", rettype = \"float32x2_t\", argtypes = \"[float32x2_t,float32x2_t,float32_t]\", vals = [VectorVal [FloatVal 4.667174816131592e-2,FloatVal 6.182575225830078e-2],VectorVal [FloatVal 0.8415547013282776,FloatVal 0.29432427883148193],FloatVal 0.6003614664077759], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_f32(UINT64_C(0x3d7d3d003d3f2ae0));
      arg2 = vcreate_f32(UINT64_C(0x3e96b1ac3f577021));
      arg3 = ((float32_t) 0.6003614664077759);
      clear_neon_saturated();
      //  Expect: "result" = 3e7440583f0d49e5
      result = vfma_n_f32(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result, 0);
         exp = ((float32_t) 0.5519087910652161);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result, 1);
         exp = ((float32_t) 0.23852670192718506);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
   }
}
}
void dotests_2275() {

{
   {
      float32x4_t arg1;
      float32x4_t arg2;
      float32_t arg3;
      float32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"mla\", fnname = \"vfmaq_n_f32\", rettype = \"float32x4_t\", argtypes = \"[float32x4_t,float32x4_t,float32_t]\", vals = [VectorVal [FloatVal 0.4008479714393616,FloatVal 0.46635985374450684,FloatVal 0.9849705100059509,FloatVal 4.286158084869385e-2],VectorVal [FloatVal 0.8994861245155334,FloatVal 0.3007018566131592,FloatVal 0.1059720516204834,FloatVal 0.8419565558433533],FloatVal 0.20314925909042358], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_f32(vcreate_f32(UINT64_C(0x3eeec6b83ecd3bf2)),
                          vcreate_f32(UINT64_C(0x3d2f8fa03f7c2707)));
      arg2 = vcombine_f32(vcreate_f32(UINT64_C(0x3e99f5983f6644b9)),
                          vcreate_f32(UINT64_C(0x3f578a773dd907e0)));
      arg3 = ((float32_t) 0.20314925909042358);
      clear_neon_saturated();
      //  Expect: "result" = 3e5b09c33f80d4f33f0706c83f15655d
      result = vfmaq_n_f32(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 0);
         exp = ((float32_t) 0.5835779309272766);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 1);
         exp = ((float32_t) 0.5274472236633301);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 2);
         exp = ((float32_t) 1.0064986944198608);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 2 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 3);
         exp = ((float32_t) 0.21390442550182343);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 3 ", exp, got);
            }
      }
   }
}
}
void dotests_2276() {

{
   {
      float32x2_t arg1;
      float32x2_t arg2;
      float32_t arg3;
      float32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"mla\", fnname = \"vmla_n_f32\", rettype = \"float32x2_t\", argtypes = \"[float32x2_t,float32x2_t,float32_t]\", vals = [VectorVal [FloatVal 0.23163199424743652,FloatVal 0.8198176622390747],VectorVal [FloatVal 0.4622836112976074,FloatVal 0.7573291659355164],FloatVal 0.7785261869430542], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_f32(UINT64_C(0x3f51df923e6d30f0));
      arg2 = vcreate_f32(UINT64_C(0x3f41e0533eecb070));
      arg3 = ((float32_t) 0.7785261869430542);
      clear_neon_saturated();
      //  Expect: "result" = 3fb467d13f176ea2
      result = vmla_n_f32(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result, 0);
         exp = ((float32_t) 0.5915318727493286);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result, 1);
         exp = ((float32_t) 1.4094182252883911);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
   }
}
}
void dotests_2277() {

{
   {
      float32x4_t arg1;
      float32x4_t arg2;
      float32_t arg3;
      float32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"mla\", fnname = \"vmlaq_n_f32\", rettype = \"float32x4_t\", argtypes = \"[float32x4_t,float32x4_t,float32_t]\", vals = [VectorVal [FloatVal 0.4119234085083008,FloatVal 0.5924634337425232,FloatVal 0.6508662104606628,FloatVal 0.438088059425354],VectorVal [FloatVal 0.555210292339325,FloatVal 0.34168434143066406,FloatVal 0.7378857731819153,FloatVal 0.4918035864830017],FloatVal 0.27276289463043213], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_f32(vcreate_f32(UINT64_C(0x3f17abaf3ed2e7a0)),
                          vcreate_f32(UINT64_C(0x3ee04d143f269f2b)));
      arg2 = vcombine_f32(vcreate_f32(UINT64_C(0x3eaef1403f0e2243)),
                          vcreate_f32(UINT64_C(0x3efbcdae3f3ce615)));
      arg3 = ((float32_t) 0.27276289463043213);
      clear_neon_saturated();
      //  Expect: "result" = 3f127deb3f5a25753f2f87903f1038a2
      result = vmlaq_n_f32(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 0);
         exp = ((float32_t) 0.5633641481399536);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 1);
         exp = ((float32_t) 0.6856622695922852);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 2);
         exp = ((float32_t) 0.8521340489387512);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 2 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 3);
         exp = ((float32_t) 0.5722338557243347);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 3 ", exp, got);
            }
      }
   }
}
}
void dotests_2278() {

{
   {
      int32x4_t arg1;
      int16x4_t arg2;
      int16_t arg3;
      int32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"mla\", fnname = \"vmlal_n_s16\", rettype = \"int32x4_t\", argtypes = \"[int32x4_t,int16x4_t,int16_t]\", vals = [VectorVal [IntegerVal (-32769),IntegerVal 0,IntegerVal (-32769),IntegerVal (-1)],VectorVal [IntegerVal (-1),IntegerVal (-32768),IntegerVal 0,IntegerVal 0],IntegerVal 32767], start_saturated = True}";
      int reported = 0;
      arg1 = vcombine_s32(vcreate_s32(UINT64_C(0x00000000ffff7fff)),
                          vcreate_s32(UINT64_C(0xffffffffffff7fff)));
      arg2 = vcreate_s16(UINT64_C(0x000000008000ffff));
      arg3 = 32767;
      set_neon_saturated();
      //  Expect: "result" = ffffffffffff7fffc0008000ffff0000
      result = vmlal_n_s16(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 0);
         exp = UINT64_C(0xc0008000ffff0000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 1);
         exp = UINT64_C(0xffffffffffff7fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2279() {

{
   {
      int64x2_t arg1;
      int32x2_t arg2;
      int32_t arg3;
      int64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"mla\", fnname = \"vmlal_n_s32\", rettype = \"int64x2_t\", argtypes = \"[int64x2_t,int32x2_t,int32_t]\", vals = [VectorVal [IntegerVal 281470681746210,IntegerVal 9223372035835625471],VectorVal [IntegerVal 32768,IntegerVal 2147418112],IntegerVal (-10434)], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s64(vcreate_s64(UINT64_C(0x0000ffff00000b22)),
                          vcreate_s64(UINT64_C(0x7fffffffc340ffff)));
      arg2 = vcreate_s32(UINT64_C(0x7fff000000008000));
      arg3 = -10434;
      clear_neon_saturated();
      //  Expect: "result" = 7fffeb9eec02ffff0000fffeeb9f0b22
      result = vmlal_n_s32(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 0);
         exp = UINT64_C(0x0000fffeeb9f0b22);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 1);
         exp = UINT64_C(0x7fffeb9eec02ffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2280() {

{
   {
      uint32x4_t arg1;
      uint16x4_t arg2;
      uint16_t arg3;
      uint32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"mla\", fnname = \"vmlal_n_u16\", rettype = \"uint32x4_t\", argtypes = \"[uint32x4_t,uint16x4_t,uint16_t]\", vals = [VectorVal [IntegerVal 0,IntegerVal 2147516415,IntegerVal 4294967295,IntegerVal 2147516415],VectorVal [IntegerVal 32767,IntegerVal 65535,IntegerVal 18484,IntegerVal 17614],IntegerVal 41332], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u32(vcreate_u32(UINT64_C(0x80007fff00000000)),
                          vcreate_u32(UINT64_C(0x80007fffffffffff)));
      arg2 = vcreate_u16(UINT64_C(0x44ce4834ffff7fff));
      arg3 = 41332U;
      clear_neon_saturated();
      //  Expect: "result" = ab653b572d896b8f2173de8b50b95e8c
      result = vmlal_n_u16(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 0);
         exp = UINT64_C(0x2173de8b50b95e8c);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 1);
         exp = UINT64_C(0xab653b572d896b8f);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2281() {

{
   {
      uint64x2_t arg1;
      uint32x2_t arg2;
      uint32_t arg3;
      uint64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"mla\", fnname = \"vmlal_n_u32\", rettype = \"uint64x2_t\", argtypes = \"[uint64x2_t,uint32x2_t,uint32_t]\", vals = [VectorVal [IntegerVal 18446744069414617088,IntegerVal 9223372039002292224],VectorVal [IntegerVal 2147450880,IntegerVal 4294901760],IntegerVal 65535], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u64(vcreate_u64(UINT64_C(0xffffffff00008000)),
                          vcreate_u64(UINT64_C(0x8000000080008000)));
      arg2 = vcreate_u32(UINT64_C(0xffff00007fff8000));
      arg3 = 65535U;
      clear_neon_saturated();
      //  Expect: "result" = 8000fffe8001800000007ffe00010000
      result = vmlal_n_u32(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 0);
         exp = UINT64_C(0x00007ffe00010000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 1);
         exp = UINT64_C(0x8000fffe80018000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2282() {

{
   {
      int32x4_t arg1;
      int16x8_t arg2;
      int16_t arg3;
      int32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"mla\", fnname = \"vmlal_high_n_s16\", rettype = \"int32x4_t\", argtypes = \"[int32x4_t,int16x8_t,int16_t]\", vals = [VectorVal [IntegerVal (-1),IntegerVal 0,IntegerVal (-2147483648),IntegerVal 32768],VectorVal [IntegerVal 32767,IntegerVal (-14134),IntegerVal (-32768),IntegerVal (-32768),IntegerVal 32767,IntegerVal 32767,IntegerVal 0,IntegerVal 0],IntegerVal (-1)], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s32(vcreate_s32(UINT64_C(0x00000000ffffffff)),
                          vcreate_s32(UINT64_C(0x0000800080000000)));
      arg2 = vcombine_s16(vcreate_s16(UINT64_C(0x80008000c8ca7fff)),
                          vcreate_s16(UINT64_C(0x000000007fff7fff)));
      arg3 = -1;
      clear_neon_saturated();
      //  Expect: "result" = 0000800080000000ffff8001ffff8000
      result = vmlal_high_n_s16(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 0);
         exp = UINT64_C(0xffff8001ffff8000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 1);
         exp = UINT64_C(0x0000800080000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2283() {

{
   {
      int64x2_t arg1;
      int32x4_t arg2;
      int32_t arg3;
      int64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"mla\", fnname = \"vmlal_high_n_s32\", rettype = \"int64x2_t\", argtypes = \"[int64x2_t,int32x4_t,int32_t]\", vals = [VectorVal [IntegerVal 140738448064511,IntegerVal 9223231298829811711],VectorVal [IntegerVal (-2147450880),IntegerVal (-1205378289),IntegerVal (-2147483648),IntegerVal (-32768)],IntegerVal 822837247], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s64(vcreate_s64(UINT64_C(0x000080003933ffff)),
                          vcreate_s64(UINT64_C(0x7fff7fffe003ffff)));
      arg2 = vcombine_s32(vcreate_s32(UINT64_C(0xb827630f80008000)),
                          vcreate_s32(UINT64_C(0xffff800080000000)));
      arg3 = 822837247;
      clear_neon_saturated();
      //  Expect: "result" = 7fff677a20047fffe77ac000b933ffff
      result = vmlal_high_n_s32(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 0);
         exp = UINT64_C(0xe77ac000b933ffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 1);
         exp = UINT64_C(0x7fff677a20047fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2284() {

{
   {
      uint32x4_t arg1;
      uint16x8_t arg2;
      uint16_t arg3;
      uint32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"mla\", fnname = \"vmlal_high_n_u16\", rettype = \"uint32x4_t\", argtypes = \"[uint32x4_t,uint16x8_t,uint16_t]\", vals = [VectorVal [IntegerVal 2147450879,IntegerVal 3700457472,IntegerVal 922058752,IntegerVal 1930756096],VectorVal [IntegerVal 46182,IntegerVal 32768,IntegerVal 65535,IntegerVal 32767,IntegerVal 0,IntegerVal 65535,IntegerVal 32768,IntegerVal 32768],IntegerVal 65535], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u32(vcreate_u32(UINT64_C(0xdc9080007fff7fff)),
                          vcreate_u32(UINT64_C(0x7315000036f58000)));
      arg2 = vcombine_u16(vcreate_u16(UINT64_C(0x7fffffff8000b466)),
                          vcreate_u16(UINT64_C(0x80008000ffff0000)));
      arg3 = 65535U;
      clear_neon_saturated();
      //  Expect: "result" = f3148000b6f50000dc8e80017fff7fff
      result = vmlal_high_n_u16(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 0);
         exp = UINT64_C(0xdc8e80017fff7fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 1);
         exp = UINT64_C(0xf3148000b6f50000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2285() {

{
   {
      uint64x2_t arg1;
      uint32x4_t arg2;
      uint32_t arg3;
      uint64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"mla\", fnname = \"vmlal_high_n_u32\", rettype = \"uint64x2_t\", argtypes = \"[uint64x2_t,uint32x4_t,uint32_t]\", vals = [VectorVal [IntegerVal 281472829194240,IntegerVal 9223372034707259392],VectorVal [IntegerVal 2147549183,IntegerVal 65535,IntegerVal 3957981184,IntegerVal 2147516416],IntegerVal 2147549183], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u64(vcreate_u64(UINT64_C(0x0000ffff7fff8000)),
                          vcreate_u64(UINT64_C(0x7fffffff7fff8000)));
      arg2 = vcombine_u32(vcreate_u32(UINT64_C(0x0000ffff8000ffff)),
                          vcreate_u32(UINT64_C(0x80008000ebea0000)));
      arg3 = 2147549183U;
      clear_neon_saturated();
      //  Expect: "result" = c000bfff7fff000075f6ebe894158000
      result = vmlal_high_n_u32(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 0);
         exp = UINT64_C(0x75f6ebe894158000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 1);
         exp = UINT64_C(0xc000bfff7fff0000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2286() {

{
   {
      int32x4_t arg1;
      int16x4_t arg2;
      int16_t arg3;
      int32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"qdmla\", fnname = \"vqdmlal_n_s16\", rettype = \"int32x4_t\", argtypes = \"[int32x4_t,int16x4_t,int16_t]\", vals = [VectorVal [IntegerVal 0,IntegerVal 0,IntegerVal (-65536),IntegerVal (-2147418113)],VectorVal [IntegerVal (-1),IntegerVal 28187,IntegerVal (-5372),IntegerVal (-1)],IntegerVal (-1)], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s32(vcreate_s32(0),
                          vcreate_s32(UINT64_C(0x8000ffffffff0000)));
      arg2 = vcreate_s16(UINT64_C(0xffffeb046e1bffff));
      arg3 = -1;
      clear_neon_saturated();
      //  Expect: "result" = 80010001ffff29f8ffff23ca00000002
      result = vqdmlal_n_s16(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 0);
         exp = UINT64_C(0xffff23ca00000002);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 1);
         exp = UINT64_C(0x80010001ffff29f8);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2287() {

{
   {
      int64x2_t arg1;
      int32x2_t arg2;
      int32_t arg3;
      int64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"qdmla\", fnname = \"vqdmlal_n_s32\", rettype = \"int64x2_t\", argtypes = \"[int64x2_t,int32x2_t,int32_t]\", vals = [VectorVal [IntegerVal (-9223231297218936832),IntegerVal 281470681808895],VectorVal [IntegerVal 2147450880,IntegerVal (-2147450880)],IntegerVal 2147483647], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s64(vcreate_s64(UINT64_C(0x8000800080000000)),
                          vcreate_s64(UINT64_C(0x0000ffff0000ffff)));
      arg2 = vcreate_s32(UINT64_C(0x800080007fff8000));
      arg3 = 2147483647;
      clear_neon_saturated();
      //  Expect: "result" = 80017fffffffffffffffffff80010000
      result = vqdmlal_n_s32(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 0);
         exp = UINT64_C(0xffffffff80010000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 1);
         exp = UINT64_C(0x80017fffffffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2288() {

{
   {
      int32x4_t arg1;
      int16x8_t arg2;
      int16_t arg3;
      int32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"qdmla\", fnname = \"vqdmlal_high_n_s16\", rettype = \"int32x4_t\", argtypes = \"[int32x4_t,int16x8_t,int16_t]\", vals = [VectorVal [IntegerVal 0,IntegerVal 1436385280,IntegerVal (-2147418113),IntegerVal 1207548017],VectorVal [IntegerVal 24487,IntegerVal 0,IntegerVal (-32768),IntegerVal 0,IntegerVal 32767,IntegerVal (-23986),IntegerVal 1543,IntegerVal 0],IntegerVal 0], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s32(vcreate_s32(UINT64_C(0x559d800000000000)),
                          vcreate_s32(UINT64_C(0x47f9b8718000ffff)));
      arg2 = vcombine_s16(vcreate_s16(UINT64_C(0x0000800000005fa7)),
                          vcreate_s16(UINT64_C(0x00000607a24e7fff)));
      arg3 = 0;
      clear_neon_saturated();
      //  Expect: "result" = 47f9b8718000ffff559d800000000000
      result = vqdmlal_high_n_s16(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 0);
         exp = UINT64_C(0x559d800000000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 1);
         exp = UINT64_C(0x47f9b8718000ffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2289() {

{
   {
      int64x2_t arg1;
      int32x4_t arg2;
      int32_t arg3;
      int64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"qdmla\", fnname = \"vqdmlal_high_n_s32\", rettype = \"int64x2_t\", argtypes = \"[int64x2_t,int32x4_t,int32_t]\", vals = [VectorVal [IntegerVal 140735340820125,IntegerVal (-1939081114559709185)],VectorVal [IntegerVal (-38656),IntegerVal 2147483647,IntegerVal (-1),IntegerVal 426635022],IntegerVal 65535], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s64(vcreate_s64(UINT64_C(0x00007fff7fff369d)),
                          vcreate_s64(UINT64_C(0xe516ffffffffffff)));
      arg2 = vcombine_s32(vcreate_s32(UINT64_C(0x7fffffffffff6900)),
                          vcreate_s32(UINT64_C(0x196def0effffffff)));
      arg3 = 65535;
      clear_neon_saturated();
      //  Expect: "result" = e51732dbab4021e300007fff7ffd369f
      result = vqdmlal_high_n_s32(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 0);
         exp = UINT64_C(0x00007fff7ffd369f);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 1);
         exp = UINT64_C(0xe51732dbab4021e3);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2290() {

{
   {
      int16x4_t arg1;
      int16x4_t arg2;
      int16_t arg3;
      int16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"mls\", fnname = \"vmls_n_s16\", rettype = \"int16x4_t\", argtypes = \"[int16x4_t,int16x4_t,int16_t]\", vals = [VectorVal [IntegerVal 29965,IntegerVal (-32768),IntegerVal (-1),IntegerVal (-3463)],VectorVal [IntegerVal 0,IntegerVal (-1),IntegerVal 0,IntegerVal 32767],IntegerVal (-32768)], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s16(UINT64_C(0xf279ffff8000750d));
      arg2 = vcreate_s16(UINT64_C(0x7fff0000ffff0000));
      arg3 = -32768;
      clear_neon_saturated();
      //  Expect: "result" = 7279ffff0000750d
      result = vmls_n_s16(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s16(result), 0);
      exp = UINT64_C(0x7279ffff0000750d);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2291() {

{
   {
      int32x2_t arg1;
      int32x2_t arg2;
      int32_t arg3;
      int32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"mls\", fnname = \"vmls_n_s32\", rettype = \"int32x2_t\", argtypes = \"[int32x2_t,int32x2_t,int32_t]\", vals = [VectorVal [IntegerVal 2147450880,IntegerVal 65535],VectorVal [IntegerVal (-65536),IntegerVal (-643378905)],IntegerVal (-1)], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s32(UINT64_C(0x0000ffff7fff8000));
      arg2 = vcreate_s32(UINT64_C(0xd9a6d127ffff0000));
      arg3 = -1;
      clear_neon_saturated();
      //  Expect: "result" = d9a7d1267ffe8000
      result = vmls_n_s32(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s32(result), 0);
      exp = UINT64_C(0xd9a7d1267ffe8000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2292() {

{
   {
      uint16x4_t arg1;
      uint16x4_t arg2;
      uint16_t arg3;
      uint16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"mls\", fnname = \"vmls_n_u16\", rettype = \"uint16x4_t\", argtypes = \"[uint16x4_t,uint16x4_t,uint16_t]\", vals = [VectorVal [IntegerVal 32767,IntegerVal 0,IntegerVal 32767,IntegerVal 32767],VectorVal [IntegerVal 32767,IntegerVal 65535,IntegerVal 32768,IntegerVal 65535],IntegerVal 65535], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u16(UINT64_C(0x7fff7fff00007fff));
      arg2 = vcreate_u16(UINT64_C(0xffff8000ffff7fff));
      arg3 = 65535U;
      clear_neon_saturated();
      //  Expect: "result" = 7ffefffffffffffe
      result = vmls_n_u16(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u16(result), 0);
      exp = UINT64_C(0x7ffefffffffffffe);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2293() {

{
   {
      uint32x2_t arg1;
      uint32x2_t arg2;
      uint32_t arg3;
      uint32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"mls\", fnname = \"vmls_n_u32\", rettype = \"uint32x2_t\", argtypes = \"[uint32x2_t,uint32x2_t,uint32_t]\", vals = [VectorVal [IntegerVal 462264522,IntegerVal 4294967295],VectorVal [IntegerVal 65535,IntegerVal 3716841472],IntegerVal 4294967295], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u32(UINT64_C(0xffffffff1b8d98ca));
      arg2 = vcreate_u32(UINT64_C(0xdd8a80000000ffff));
      arg3 = 4294967295U;
      clear_neon_saturated();
      //  Expect: "result" = dd8a7fff1b8e98c9
      result = vmls_n_u32(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u32(result), 0);
      exp = UINT64_C(0xdd8a7fff1b8e98c9);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2294() {

{
   {
      int16x8_t arg1;
      int16x8_t arg2;
      int16_t arg3;
      int16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"mls\", fnname = \"vmlsq_n_s16\", rettype = \"int16x8_t\", argtypes = \"[int16x8_t,int16x8_t,int16_t]\", vals = [VectorVal [IntegerVal 0,IntegerVal (-32699),IntegerVal 17417,IntegerVal 32767,IntegerVal 32767,IntegerVal (-3049),IntegerVal 32767,IntegerVal (-32768)],VectorVal [IntegerVal 7584,IntegerVal 32767,IntegerVal (-32768),IntegerVal 32767,IntegerVal (-1),IntegerVal 32767,IntegerVal (-15223),IntegerVal 0],IntegerVal (-1)], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s16(vcreate_s16(UINT64_C(0x7fff440980450000)),
                          vcreate_s16(UINT64_C(0x80007ffff4177fff)));
      arg2 = vcombine_s16(vcreate_s16(UINT64_C(0x7fff80007fff1da0)),
                          vcreate_s16(UINT64_C(0x0000c4897fffffff)));
      arg3 = -1;
      clear_neon_saturated();
      //  Expect: "result" = 8000448874167ffefffec40900441da0
      result = vmlsq_n_s16(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 0);
         exp = UINT64_C(0xfffec40900441da0);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 1);
         exp = UINT64_C(0x8000448874167ffe);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2295() {

{
   {
      int32x4_t arg1;
      int32x4_t arg2;
      int32_t arg3;
      int32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"mls\", fnname = \"vmlsq_n_s32\", rettype = \"int32x4_t\", argtypes = \"[int32x4_t,int32x4_t,int32_t]\", vals = [VectorVal [IntegerVal (-2147450881),IntegerVal (-2074031445),IntegerVal 2147450879,IntegerVal (-15238)],VectorVal [IntegerVal (-2147450880),IntegerVal (-869367809),IntegerVal 65535,IntegerVal (-1091983354)],IntegerVal 0], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s32(vcreate_s32(UINT64_C(0x8460caab80007fff)),
                          vcreate_s32(UINT64_C(0xffffc47a7fff7fff)));
      arg2 = vcombine_s32(vcreate_s32(UINT64_C(0xcc2e7fff80008000)),
                          vcreate_s32(UINT64_C(0xbee9a8060000ffff)));
      arg3 = 0;
      clear_neon_saturated();
      //  Expect: "result" = ffffc47a7fff7fff8460caab80007fff
      result = vmlsq_n_s32(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 0);
         exp = UINT64_C(0x8460caab80007fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 1);
         exp = UINT64_C(0xffffc47a7fff7fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2296() {

{
   {
      uint16x8_t arg1;
      uint16x8_t arg2;
      uint16_t arg3;
      uint16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"mls\", fnname = \"vmlsq_n_u16\", rettype = \"uint16x8_t\", argtypes = \"[uint16x8_t,uint16x8_t,uint16_t]\", vals = [VectorVal [IntegerVal 32768,IntegerVal 65535,IntegerVal 32768,IntegerVal 5828,IntegerVal 8174,IntegerVal 8121,IntegerVal 32768,IntegerVal 32767],VectorVal [IntegerVal 50970,IntegerVal 65535,IntegerVal 65535,IntegerVal 32768,IntegerVal 32767,IntegerVal 0,IntegerVal 32768,IntegerVal 32767],IntegerVal 32768], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u16(vcreate_u16(UINT64_C(0x16c48000ffff8000)),
                          vcreate_u16(UINT64_C(0x7fff80001fb91fee)));
      arg2 = vcombine_u16(vcreate_u16(UINT64_C(0x8000ffffffffc71a)),
                          vcreate_u16(UINT64_C(0x7fff800000007fff)));
      arg3 = 32768U;
      clear_neon_saturated();
      //  Expect: "result" = ffff80001fb99fee16c400007fff8000
      result = vmlsq_n_u16(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 0);
         exp = UINT64_C(0x16c400007fff8000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 1);
         exp = UINT64_C(0xffff80001fb99fee);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2297() {

{
   {
      uint32x4_t arg1;
      uint32x4_t arg2;
      uint32_t arg3;
      uint32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"mls\", fnname = \"vmlsq_n_u32\", rettype = \"uint32x4_t\", argtypes = \"[uint32x4_t,uint32x4_t,uint32_t]\", vals = [VectorVal [IntegerVal 4294967295,IntegerVal 0,IntegerVal 1954054144,IntegerVal 4294967295],VectorVal [IntegerVal 2147549183,IntegerVal 2147549183,IntegerVal 2147450880,IntegerVal 0],IntegerVal 2717614080], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u32(vcreate_u32(UINT64_C(0x00000000ffffffff)),
                          vcreate_u32(UINT64_C(0xffffffff74788000)));
      arg2 = vcombine_u32(vcreate_u32(UINT64_C(0x8000ffff8000ffff)),
                          vcreate_u32(UINT64_C(0x000000007fff8000)));
      arg3 = 2717614080U;
      clear_neon_saturated();
      //  Expect: "result" = ffffffff3478800021fb800021fb7fff
      result = vmlsq_n_u32(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 0);
         exp = UINT64_C(0x21fb800021fb7fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 1);
         exp = UINT64_C(0xffffffff34788000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2298() {

{
   {
      int32x4_t arg1;
      int16x4_t arg2;
      int16_t arg3;
      int32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"mls\", fnname = \"vmlsl_n_s16\", rettype = \"int32x4_t\", argtypes = \"[int32x4_t,int16x4_t,int16_t]\", vals = [VectorVal [IntegerVal 1007616000,IntegerVal 2147450879,IntegerVal (-2047180800),IntegerVal 32768],VectorVal [IntegerVal (-20050),IntegerVal 18354,IntegerVal 29902,IntegerVal (-32768)],IntegerVal 32767], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s32(vcreate_s32(UINT64_C(0x7fff7fff3c0f0000)),
                          vcreate_s32(UINT64_C(0x0000800085fa8000)));
      arg2 = vcreate_s16(UINT64_C(0x800074ce47b2b1ae));
      arg3 = 32767;
      clear_neon_saturated();
      //  Expect: "result" = 400000004b93f4ce5c26c7b16337b1ae
      result = vmlsl_n_s16(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 0);
         exp = UINT64_C(0x5c26c7b16337b1ae);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 1);
         exp = UINT64_C(0x400000004b93f4ce);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2299() {

{
   {
      int64x2_t arg1;
      int32x2_t arg2;
      int32_t arg3;
      int64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"mls\", fnname = \"vmlsl_n_s32\", rettype = \"int64x2_t\", argtypes = \"[int64x2_t,int32x2_t,int32_t]\", vals = [VectorVal [IntegerVal 140737488322560,IntegerVal (-4294967296)],VectorVal [IntegerVal 65535,IntegerVal 32767],IntegerVal (-2147450880)], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s64(vcreate_s64(UINT64_C(0x00007fffffff8000)),
                          vcreate_s64(UINT64_C(0xffffffff00000000)));
      arg2 = vcreate_s32(UINT64_C(0x00007fff0000ffff));
      arg3 = -2147450880;
      clear_neon_saturated();
      //  Expect: "result" = 00003ffe400080000000ffff00000000
      result = vmlsl_n_s32(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 0);
         exp = UINT64_C(0x0000ffff00000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 1);
         exp = UINT64_C(0x00003ffe40008000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2300() {

{
   {
      uint32x4_t arg1;
      uint16x4_t arg2;
      uint16_t arg3;
      uint32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"mls\", fnname = \"vmlsl_n_u16\", rettype = \"uint32x4_t\", argtypes = \"[uint32x4_t,uint16x4_t,uint16_t]\", vals = [VectorVal [IntegerVal 32768,IntegerVal 2147516443,IntegerVal 4294901760,IntegerVal 1976238079],VectorVal [IntegerVal 262,IntegerVal 0,IntegerVal 44392,IntegerVal 32767],IntegerVal 32768], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u32(vcreate_u32(UINT64_C(0x8000801b00008000)),
                          vcreate_u32(UINT64_C(0x75caffffffff0000)));
      arg2 = vcreate_u16(UINT64_C(0x7fffad6800000106));
      arg3 = 32768U;
      clear_neon_saturated();
      //  Expect: "result" = 35cb7fffa94b00008000801bff7d8000
      result = vmlsl_n_u16(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 0);
         exp = UINT64_C(0x8000801bff7d8000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 1);
         exp = UINT64_C(0x35cb7fffa94b0000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2301() {

{
   {
      uint64x2_t arg1;
      uint32x2_t arg2;
      uint32_t arg3;
      uint64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"mls\", fnname = \"vmlsl_n_u32\", rettype = \"uint64x2_t\", argtypes = \"[uint64x2_t,uint32x2_t,uint32_t]\", vals = [VectorVal [IntegerVal 9223231301513871360,IntegerVal 17188617246402950824],VectorVal [IntegerVal 1825013759,IntegerVal 2748284927],IntegerVal 2147450880], start_saturated = True}";
      int reported = 0;
      arg1 = vcombine_u64(vcreate_u64(UINT64_C(0x7fff80007fff8000)),
                          vcreate_u64(UINT64_C(0xee8a3c51000036a8)));
      arg2 = vcreate_u32(UINT64_C(0xa3cf7fff6cc77fff));
      arg3 = 2147450880U;
      set_neon_saturated();
      //  Expect: "result" = 9ca2ce393fffb6a8499bf664bfff0000
      result = vmlsl_n_u32(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 0);
         exp = UINT64_C(0x499bf664bfff0000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 1);
         exp = UINT64_C(0x9ca2ce393fffb6a8);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2302() {

{
   {
      int32x4_t arg1;
      int16x8_t arg2;
      int16_t arg3;
      int32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"mls\", fnname = \"vmlsl_high_n_s16\", rettype = \"int32x4_t\", argtypes = \"[int32x4_t,int16x8_t,int16_t]\", vals = [VectorVal [IntegerVal 1699839999,IntegerVal 65535,IntegerVal (-32769),IntegerVal (-216585582)],VectorVal [IntegerVal (-32768),IntegerVal (-32768),IntegerVal (-32768),IntegerVal (-32768),IntegerVal (-32768),IntegerVal (-32768),IntegerVal (-1),IntegerVal 0],IntegerVal 32767], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s32(vcreate_s32(UINT64_C(0x0000ffff65517fff)),
                          vcreate_s32(UINT64_C(0xf3172a92ffff7fff)));
      arg2 = vcombine_s16(vcreate_s16(UINT64_C(0x8000800080008000)),
                          vcreate_s16(UINT64_C(0x0000ffff80008000)));
      arg3 = 32767;
      clear_neon_saturated();
      //  Expect: "result" = f3172a92fffffffe40007fffa550ffff
      result = vmlsl_high_n_s16(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 0);
         exp = UINT64_C(0x40007fffa550ffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 1);
         exp = UINT64_C(0xf3172a92fffffffe);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2303() {

{
   {
      int64x2_t arg1;
      int32x4_t arg2;
      int32_t arg3;
      int64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"mls\", fnname = \"vmlsl_high_n_s32\", rettype = \"int64x2_t\", argtypes = \"[int64x2_t,int32x4_t,int32_t]\", vals = [VectorVal [IntegerVal (-2147418113),IntegerVal 140735340838912],VectorVal [IntegerVal 1829585857,IntegerVal 32767,IntegerVal (-2147450881),IntegerVal 987299840],IntegerVal 65535], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s64(vcreate_s64(UINT64_C(0xffffffff8000ffff)),
                          vcreate_s64(UINT64_C(0x00007fff7fff8000)));
      arg2 = vcombine_s32(vcreate_s32(UINT64_C(0x00007fff6d0d43c1)),
                          vcreate_s32(UINT64_C(0x3ad9000080007fff)));
      arg3 = 65535;
      clear_neon_saturated();
      //  Expect: "result" = 00004526bad8800000007ffe80027ffe
      result = vmlsl_high_n_s32(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 0);
         exp = UINT64_C(0x00007ffe80027ffe);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 1);
         exp = UINT64_C(0x00004526bad88000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2304() {

{
   {
      uint32x4_t arg1;
      uint16x8_t arg2;
      uint16_t arg3;
      uint32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"mls\", fnname = \"vmlsl_high_n_u16\", rettype = \"uint32x4_t\", argtypes = \"[uint32x4_t,uint16x8_t,uint16_t]\", vals = [VectorVal [IntegerVal 4294920519,IntegerVal 4294960100,IntegerVal 2147516416,IntegerVal 4294916143],VectorVal [IntegerVal 32768,IntegerVal 0,IntegerVal 32767,IntegerVal 0,IntegerVal 0,IntegerVal 0,IntegerVal 19717,IntegerVal 65535],IntegerVal 64981], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u32(vcreate_u32(UINT64_C(0xffffe3e4ffff4947)),
                          vcreate_u32(UINT64_C(0xffff382f80008000)));
      arg2 = vcombine_u16(vcreate_u16(UINT64_C(0x00007fff00008000)),
                          vcreate_u16(UINT64_C(0xffff4d0500000000)));
      arg3 = 64981U;
      clear_neon_saturated();
      //  Expect: "result" = 022b360433a279d7ffffe3e4ffff4947
      result = vmlsl_high_n_u16(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 0);
         exp = UINT64_C(0xffffe3e4ffff4947);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 1);
         exp = UINT64_C(0x022b360433a279d7);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2305() {

{
   {
      uint64x2_t arg1;
      uint32x4_t arg2;
      uint32_t arg3;
      uint64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"mls\", fnname = \"vmlsl_high_n_u32\", rettype = \"uint64x2_t\", argtypes = \"[uint64x2_t,uint32x4_t,uint32_t]\", vals = [VectorVal [IntegerVal 18446603334073710128,IntegerVal 281472829161472],VectorVal [IntegerVal 1499882339,IntegerVal 2147538086,IntegerVal 2147516415,IntegerVal 2147516415],IntegerVal 40826], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u64(vcreate_u64(UINT64_C(0xffff7fff7ffff630)),
                          vcreate_u64(UINT64_C(0x0000ffff7fff0000)));
      arg2 = vcombine_u32(vcreate_u32(UINT64_C(0x8000d4a659666363)),
                          vcreate_u32(UINT64_C(0x80007fff80007fff)));
      arg3 = 40826U;
      clear_neon_saturated();
      //  Expect: "result" = 0000b04230429f7affff3042304395aa
      result = vmlsl_high_n_u32(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 0);
         exp = UINT64_C(0xffff3042304395aa);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 1);
         exp = UINT64_C(0x0000b04230429f7a);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2306() {

{
   {
      float32x2_t arg1;
      float32x2_t arg2;
      float32_t arg3;
      float32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"mls\", fnname = \"vmls_n_f32\", rettype = \"float32x2_t\", argtypes = \"[float32x2_t,float32x2_t,float32_t]\", vals = [VectorVal [FloatVal 0.3731399178504944,FloatVal 0.4092155694961548],VectorVal [FloatVal 8.946722745895386e-2,FloatVal 0.49175429344177246],FloatVal 0.20049142837524414], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_f32(UINT64_C(0x3ed184b43ebf0c32));
      arg2 = vcreate_f32(UINT64_C(0x3efbc7383db73a98));
      arg3 = ((float32_t) 0.20049142837524414);
      clear_neon_saturated();
      //  Expect: "result" = 3e9f09fc3eb5dd1a
      result = vmls_n_f32(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result, 0);
         exp = ((float32_t) 0.35520249605178833);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result, 1);
         exp = ((float32_t) 0.31062304973602295);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
   }
}
}
void dotests_2307() {

{
   {
      float32x4_t arg1;
      float32x4_t arg2;
      float32_t arg3;
      float32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"mls\", fnname = \"vmlsq_n_f32\", rettype = \"float32x4_t\", argtypes = \"[float32x4_t,float32x4_t,float32_t]\", vals = [VectorVal [FloatVal 0.8980887532234192,FloatVal 0.655251145362854,FloatVal 0.9801900386810303,FloatVal 0.469887912273407],VectorVal [FloatVal 6.283634901046753e-2,FloatVal 0.9923125505447388,FloatVal 0.9068330526351929,FloatVal 0.7256094217300415],FloatVal 0.16887879371643066], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_f32(vcreate_f32(UINT64_C(0x3f27be8a3f65e925)),
                          vcreate_f32(UINT64_C(0x3ef095263f7aedbc)));
      arg2 = vcombine_f32(vcreate_f32(UINT64_C(0x3f7e08323d80b058)),
                          vcreate_f32(UINT64_C(0x3f39c18a3f682636)));
      arg3 = ((float32_t) 0.16887879371643066);
      clear_neon_saturated();
      //  Expect: "result" = 3eb1d7943f53b93b3ef9aff63f6331b2
      result = vmlsq_n_f32(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 0);
         exp = ((float32_t) 0.8874770402908325);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 1);
         exp = ((float32_t) 0.4876706004142761);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 2);
         exp = ((float32_t) 0.8270451426506042);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 2 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 3);
         exp = ((float32_t) 0.34734785556793213);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 3 ", exp, got);
            }
      }
   }
}
}
void dotests_2308() {

{
   {
      float32x2_t arg1;
      float32x2_t arg2;
      float32_t arg3;
      float32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"mls\", fnname = \"vfms_n_f32\", rettype = \"float32x2_t\", argtypes = \"[float32x2_t,float32x2_t,float32_t]\", vals = [VectorVal [FloatVal 0.6544234156608582,FloatVal 0.19382017850875854],VectorVal [FloatVal 0.7019359469413757,FloatVal 0.6284117102622986],FloatVal 0.3539101481437683], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_f32(UINT64_C(0x3e4678cc3f27884b));
      arg2 = vcreate_f32(UINT64_C(0x3f20df973f33b213));
      arg3 = ((float32_t) 0.3539101481437683);
      clear_neon_saturated();
      //  Expect: "result" = bcea22eb3ecfdf62
      result = vfms_n_f32(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result, 0);
         exp = ((float32_t) 0.40600115060806274);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result, 1);
         exp = ((float32_t) -2.8581103309988976e-2);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
   }
}
}
void dotests_2309() {

{
   {
      float32x4_t arg1;
      float32x4_t arg2;
      float32_t arg3;
      float32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"mls\", fnname = \"vfmsq_n_f32\", rettype = \"float32x4_t\", argtypes = \"[float32x4_t,float32x4_t,float32_t]\", vals = [VectorVal [FloatVal 5.402982234954834e-2,FloatVal 0.1300722360610962,FloatVal 0.3070957064628601,FloatVal 0.7984663248062134],VectorVal [FloatVal 0.2355859875679016,FloatVal 0.2960314154624939,FloatVal 0.8409455418586731,FloatVal 0.24503040313720703],FloatVal 0.35265976190567017], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_f32(vcreate_f32(UINT64_C(0x3e0531a83d5d4e60)),
                          vcreate_f32(UINT64_C(0x3f4c684a3e9d3ba6)));
      arg2 = vcombine_f32(vcreate_f32(UINT64_C(0x3e97916e3e713d74)),
                          vcreate_f32(UINT64_C(0x3e7ae9403f574835)));
      arg3 = ((float32_t) 0.35265976190567017);
      clear_neon_saturated();
      //  Expect: "result" = 3f36492b3c2c7dda3cd25201bcedfe33
      result = vfmsq_n_f32(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 0);
         exp = ((float32_t) -2.9051875695586205e-2);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 1);
         exp = ((float32_t) 2.5673868134617805e-2);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 2);
         exp = ((float32_t) 1.0528052225708961e-2);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 2 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 3);
         exp = ((float32_t) 0.7120539546012878);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 3 ", exp, got);
            }
      }
   }
}
}
void dotests_2310() {

{
   {
      int32x4_t arg1;
      int16x4_t arg2;
      int16_t arg3;
      int32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"qdmls\", fnname = \"vqdmlsl_n_s16\", rettype = \"int32x4_t\", argtypes = \"[int32x4_t,int16x4_t,int16_t]\", vals = [VectorVal [IntegerVal (-1),IntegerVal (-2147450880),IntegerVal (-2147450880),IntegerVal 2147418112],VectorVal [IntegerVal (-32768),IntegerVal (-32768),IntegerVal 0,IntegerVal (-1)],IntegerVal (-1)], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s32(vcreate_s32(UINT64_C(0x80008000ffffffff)),
                          vcreate_s32(UINT64_C(0x7fff000080008000)));
      arg2 = vcreate_s16(UINT64_C(0xffff000080008000));
      arg3 = -1;
      clear_neon_saturated();
      //  Expect: "result" = 7ffefffe8000800080000000fffeffff
      result = vqdmlsl_n_s16(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 0);
         exp = UINT64_C(0x80000000fffeffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 1);
         exp = UINT64_C(0x7ffefffe80008000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2311() {

{
   {
      int64x2_t arg1;
      int32x2_t arg2;
      int32_t arg3;
      int64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"qdmls\", fnname = \"vqdmlsl_n_s32\", rettype = \"int64x2_t\", argtypes = \"[int64x2_t,int32x2_t,int32_t]\", vals = [VectorVal [IntegerVal 140733193388032,IntegerVal 184952029249535],VectorVal [IntegerVal 2147418112,IntegerVal (-32769)],IntegerVal 32768], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s64(vcreate_s64(UINT64_C(0x00007fff00000000)),
                          vcreate_s64(UINT64_C(0x0000a8368000ffff)));
      arg2 = vcreate_s32(UINT64_C(0xffff7fff7fff0000));
      arg3 = 32768;
      clear_neon_saturated();
      //  Expect: "result" = 0000a8370001ffff0000000000000000
      result = vqdmlsl_n_s32(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 0);
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 1);
         exp = UINT64_C(0x0000a8370001ffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2312() {

{
   {
      int32x4_t arg1;
      int16x8_t arg2;
      int16_t arg3;
      int32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"qdmls\", fnname = \"vqdmlsl_high_n_s16\", rettype = \"int32x4_t\", argtypes = \"[int32x4_t,int16x8_t,int16_t]\", vals = [VectorVal [IntegerVal (-2147450880),IntegerVal 2147483647,IntegerVal 0,IntegerVal (-1992032257)],VectorVal [IntegerVal (-6378),IntegerVal 0,IntegerVal (-32768),IntegerVal 32767,IntegerVal (-26875),IntegerVal (-32768),IntegerVal (-32768),IntegerVal (-32768)],IntegerVal 0], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s32(vcreate_s32(UINT64_C(0x7fffffff80008000)),
                          vcreate_s32(UINT64_C(0x8943ffff00000000)));
      arg2 = vcombine_s16(vcreate_s16(UINT64_C(0x7fff80000000e716)),
                          vcreate_s16(UINT64_C(0x8000800080009705)));
      arg3 = 0;
      clear_neon_saturated();
      //  Expect: "result" = 8943ffff000000007fffffff80008000
      result = vqdmlsl_high_n_s16(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 0);
         exp = UINT64_C(0x7fffffff80008000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 1);
         exp = UINT64_C(0x8943ffff00000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2313() {

{
   {
      int64x2_t arg1;
      int32x4_t arg2;
      int32_t arg3;
      int64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"qdmls\", fnname = \"vqdmlsl_high_n_s32\", rettype = \"int64x2_t\", argtypes = \"[int64x2_t,int32x4_t,int32_t]\", vals = [VectorVal [IntegerVal (-9223091843925803009),IntegerVal (-140733193420800)],VectorVal [IntegerVal 65535,IntegerVal (-2147450881),IntegerVal 0,IntegerVal 0],IntegerVal (-32768)], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s64(vcreate_s64(UINT64_C(0x8000fed57fffffff)),
                          vcreate_s64(UINT64_C(0xffff8000ffff8000)));
      arg2 = vcombine_s32(vcreate_s32(UINT64_C(0x80007fff0000ffff)),
                          vcreate_s32(0));
      arg3 = -32768;
      clear_neon_saturated();
      //  Expect: "result" = ffff8000ffff80008000fed57fffffff
      result = vqdmlsl_high_n_s32(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 0);
         exp = UINT64_C(0x8000fed57fffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 1);
         exp = UINT64_C(0xffff8000ffff8000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2314() {

{
   {
      int16x4_t arg1;
      int16_t arg2;
      int16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"mul\", fnname = \"vmul_n_s16\", rettype = \"int16x4_t\", argtypes = \"[int16x4_t,int16_t]\", vals = [VectorVal [IntegerVal (-32768),IntegerVal 0,IntegerVal (-32768),IntegerVal (-1)],IntegerVal (-1)], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s16(UINT64_C(0xffff800000008000));
      arg2 = -1;
      clear_neon_saturated();
      //  Expect: "result" = 0001800000008000
      result = vmul_n_s16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s16(result), 0);
      exp = UINT64_C(0x0001800000008000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2315() {

{
   {
      int32x2_t arg1;
      int32_t arg2;
      int32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"mul\", fnname = \"vmul_n_s32\", rettype = \"int32x2_t\", argtypes = \"[int32x2_t,int32_t]\", vals = [VectorVal [IntegerVal (-1),IntegerVal 762904576],IntegerVal (-1021147124)], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s32(UINT64_C(0x2d790000ffffffff));
      arg2 = -1021147124;
      clear_neon_saturated();
      //  Expect: "result" = 69ac00003cdd77f4
      result = vmul_n_s32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s32(result), 0);
      exp = UINT64_C(0x69ac00003cdd77f4);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2316() {

{
   {
      float32x2_t arg1;
      float32_t arg2;
      float32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"mul\", fnname = \"vmul_n_f32\", rettype = \"float32x2_t\", argtypes = \"[float32x2_t,float32_t]\", vals = [VectorVal [FloatVal 0.22787028551101685,FloatVal 0.7921562790870667],FloatVal 0.8407617807388306], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_f32(UINT64_C(0x3f4acac13e6956d4));
      arg2 = ((float32_t) 0.8407617807388306);
      clear_neon_saturated();
      //  Expect: "result" = 3f2a7ff13e442ec3
      result = vmul_n_f32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result, 0);
         exp = ((float32_t) 0.19158463180065155);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result, 1);
         exp = ((float32_t) 0.6660147309303284);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
   }
}
}
void dotests_2317() {

{
   {
      uint16x4_t arg1;
      uint16_t arg2;
      uint16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"mul\", fnname = \"vmul_n_u16\", rettype = \"uint16x4_t\", argtypes = \"[uint16x4_t,uint16_t]\", vals = [VectorVal [IntegerVal 15918,IntegerVal 65535,IntegerVal 65535,IntegerVal 6946],IntegerVal 32767], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u16(UINT64_C(0x1b22ffffffff3e2e));
      arg2 = 32767U;
      clear_neon_saturated();
      //  Expect: "result" = e4de80018001c1d2
      result = vmul_n_u16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u16(result), 0);
      exp = UINT64_C(0xe4de80018001c1d2);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2318() {

{
   {
      uint32x2_t arg1;
      uint32_t arg2;
      uint32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"mul\", fnname = \"vmul_n_u32\", rettype = \"uint32x2_t\", argtypes = \"[uint32x2_t,uint32_t]\", vals = [VectorVal [IntegerVal 4294934527,IntegerVal 4294935867],IntegerVal 2023849984], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u32(UINT64_C(0xffff853bffff7fff));
      arg2 = 2023849984U;
      clear_neon_saturated();
      //  Expect: "result" = 34b88000c75e8000
      result = vmul_n_u32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u32(result), 0);
      exp = UINT64_C(0x34b88000c75e8000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2319() {

{
   {
      int16x8_t arg1;
      int16_t arg2;
      int16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"mul\", fnname = \"vmulq_n_s16\", rettype = \"int16x8_t\", argtypes = \"[int16x8_t,int16_t]\", vals = [VectorVal [IntegerVal (-32768),IntegerVal 0,IntegerVal (-20945),IntegerVal (-234),IntegerVal (-32768),IntegerVal 0,IntegerVal (-1),IntegerVal 0],IntegerVal (-32768)], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s16(vcreate_s16(UINT64_C(0xff16ae2f00008000)),
                          vcreate_s16(UINT64_C(0x0000ffff00008000)));
      arg2 = -32768;
      clear_neon_saturated();
      //  Expect: "result" = 00008000000000000000800000000000
      result = vmulq_n_s16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 0);
         exp = UINT64_C(0x0000800000000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 1);
         exp = UINT64_C(0x0000800000000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2320() {

{
   {
      int32x4_t arg1;
      int32_t arg2;
      int32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"mul\", fnname = \"vmulq_n_s32\", rettype = \"int32x4_t\", argtypes = \"[int32x4_t,int32_t]\", vals = [VectorVal [IntegerVal (-65536),IntegerVal 32767,IntegerVal 3896,IntegerVal (-2147450880)],IntegerVal (-2147450880)], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s32(vcreate_s32(UINT64_C(0x00007fffffff0000)),
                          vcreate_s32(UINT64_C(0x8000800000000f38)));
      arg2 = -2147450880;
      clear_neon_saturated();
      //  Expect: "result" = 40000000079c0000bfff800080000000
      result = vmulq_n_s32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 0);
         exp = UINT64_C(0xbfff800080000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 1);
         exp = UINT64_C(0x40000000079c0000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2321() {

{
   {
      float32x4_t arg1;
      float32_t arg2;
      float32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"mul\", fnname = \"vmulq_n_f32\", rettype = \"float32x4_t\", argtypes = \"[float32x4_t,float32_t]\", vals = [VectorVal [FloatVal 0.9458720088005066,FloatVal 0.8973832726478577,FloatVal 0.30555129051208496,FloatVal 0.7930429577827454],FloatVal 0.7638997435569763], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_f32(vcreate_f32(UINT64_C(0x3f65bae93f7224ab)),
                          vcreate_f32(UINT64_C(0x3f4b04dd3e9c7138)));
      arg2 = ((float32_t) 0.7638997435569763);
      clear_neon_saturated();
      //  Expect: "result" = 3f1b160f3e6f032d3f2f7da43f38f921
      result = vmulq_n_f32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 0);
         exp = ((float32_t) 0.7225514054298401);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 1);
         exp = ((float32_t) 0.6855108737945557);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 2);
         exp = ((float32_t) 0.2334105521440506);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 2 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 3);
         exp = ((float32_t) 0.6058053374290466);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 3 ", exp, got);
            }
      }
   }
}
}
void dotests_2322() {

{
   {
      uint16x8_t arg1;
      uint16_t arg2;
      uint16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"mul\", fnname = \"vmulq_n_u16\", rettype = \"uint16x8_t\", argtypes = \"[uint16x8_t,uint16_t]\", vals = [VectorVal [IntegerVal 30233,IntegerVal 32768,IntegerVal 0,IntegerVal 32768,IntegerVal 32767,IntegerVal 49848,IntegerVal 32767,IntegerVal 65535],IntegerVal 0], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u16(vcreate_u16(UINT64_C(0x8000000080007619)),
                          vcreate_u16(UINT64_C(0xffff7fffc2b87fff)));
      arg2 = 0;
      clear_neon_saturated();
      //  Expect: "result" = 00000000000000000000000000000000
      result = vmulq_n_u16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 0);
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 1);
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2323() {

{
   {
      uint32x4_t arg1;
      uint32_t arg2;
      uint32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"mul\", fnname = \"vmulq_n_u32\", rettype = \"uint32x4_t\", argtypes = \"[uint32x4_t,uint32_t]\", vals = [VectorVal [IntegerVal 0,IntegerVal 4294923508,IntegerVal 4294934528,IntegerVal 2147450880],IntegerVal 956792831], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u32(vcreate_u32(UINT64_C(0xffff54f400000000)),
                          vcreate_u32(UINT64_C(0x7fff8000ffff8000)));
      arg2 = 956792831U;
      clear_neon_saturated();
      //  Expect: "result" = c0008000400080005126ab0c00000000
      result = vmulq_n_u32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 0);
         exp = UINT64_C(0x5126ab0c00000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 1);
         exp = UINT64_C(0xc000800040008000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2324() {

{
   {
      float64x1_t arg1;
      float64_t arg2;
      float64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"mul\", fnname = \"vmul_n_f64\", rettype = \"float64x1_t\", argtypes = \"[float64x1_t,float64_t]\", vals = [VectorVal [FloatVal 0.5531245303528987],FloatVal 0.6944329050739676], start_saturated = False}";
      int reported = 0;
      float64_t got;
      float64_t exp;
      arg1 = vcreate_f64(UINT64_C(0x3fe1b332370f64d6));
      arg2 = 0.6944329050739676;
      clear_neon_saturated();
      //  Expect: "result" = 3fd8953931c1f23f
      result = vmul_n_f64(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_f64(result, 0);
      exp = 0.3841078744806374;
      if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
         }
   }
}
}
void dotests_2325() {

{
   {
      float64x2_t arg1;
      float64_t arg2;
      float64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"mul\", fnname = \"vmulq_n_f64\", rettype = \"float64x2_t\", argtypes = \"[float64x2_t,float64_t]\", vals = [VectorVal [FloatVal 0.6897601522087347,FloatVal 0.8017522562545593],FloatVal 0.44465735355985503], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_f64(vcreate_f64(UINT64_C(0x3fe61283e1fa4184)),
                          vcreate_f64(UINT64_C(0x3fe9a7f4590370ff)));
      arg2 = 0.44465735355985503;
      clear_neon_saturated();
      //  Expect: "result" = 3fd6d0fa8021bc5d3fd3a11613df379d
      result = vmulq_n_f64(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float64_t got;
         float64_t exp;
         got = vgetq_lane_f64(result, 0);
         exp = 0.30670692387217874;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float64_t got;
         float64_t exp;
         got = vgetq_lane_f64(result, 1);
         exp = 0.35650503647679505;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
   }
}
}
void dotests_2326() {

{
   {
      int16x4_t arg1;
      int16_t arg2;
      int32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"mul\", fnname = \"vmull_n_s16\", rettype = \"int32x4_t\", argtypes = \"[int16x4_t,int16_t]\", vals = [VectorVal [IntegerVal (-32768),IntegerVal 0,IntegerVal (-32768),IntegerVal (-1)],IntegerVal (-1)], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_s16(UINT64_C(0xffff800000008000));
      arg2 = -1;
      clear_neon_saturated();
      //  Expect: "result" = 00000001000080000000000000008000
      result = vmull_n_s16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 0);
         exp = UINT64_C(0x0000000000008000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 1);
         exp = UINT64_C(0x0000000100008000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2327() {

{
   {
      int32x2_t arg1;
      int32_t arg2;
      int64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"mul\", fnname = \"vmull_n_s32\", rettype = \"int64x2_t\", argtypes = \"[int32x2_t,int32_t]\", vals = [VectorVal [IntegerVal (-2147450880),IntegerVal (-6570)],IntegerVal 0], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_s32(UINT64_C(0xffffe65680008000));
      arg2 = 0;
      clear_neon_saturated();
      //  Expect: "result" = 00000000000000000000000000000000
      result = vmull_n_s32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 0);
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 1);
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2328() {

{
   {
      uint16x4_t arg1;
      uint16_t arg2;
      uint32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"mul\", fnname = \"vmull_n_u16\", rettype = \"uint32x4_t\", argtypes = \"[uint16x4_t,uint16_t]\", vals = [VectorVal [IntegerVal 0,IntegerVal 0,IntegerVal 32768,IntegerVal 65535],IntegerVal 32767], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_u16(UINT64_C(0xffff800000000000));
      arg2 = 32767U;
      clear_neon_saturated();
      //  Expect: "result" = 7ffe80013fff80000000000000000000
      result = vmull_n_u16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 0);
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 1);
         exp = UINT64_C(0x7ffe80013fff8000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2329() {

{
   {
      uint32x2_t arg1;
      uint32_t arg2;
      uint64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"mul\", fnname = \"vmull_n_u32\", rettype = \"uint64x2_t\", argtypes = \"[uint32x2_t,uint32_t]\", vals = [VectorVal [IntegerVal 2147450880,IntegerVal 2380234752],IntegerVal 4294957901], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_u32(UINT64_C(0x8ddf80007fff8000));
      arg2 = 4294957901U;
      clear_neon_saturated();
      //  Expect: "result" = 8ddf6ba95eb980007fff6da692598000
      result = vmull_n_u32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 0);
         exp = UINT64_C(0x7fff6da692598000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 1);
         exp = UINT64_C(0x8ddf6ba95eb98000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2330() {

{
   {
      int16x8_t arg1;
      int16_t arg2;
      int32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"mul\", fnname = \"vmull_high_n_s16\", rettype = \"int32x4_t\", argtypes = \"[int16x8_t,int16_t]\", vals = [VectorVal [IntegerVal 1163,IntegerVal 29159,IntegerVal 0,IntegerVal 32767,IntegerVal 0,IntegerVal (-32768),IntegerVal (-32768),IntegerVal (-1)],IntegerVal 32767], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s16(vcreate_s16(UINT64_C(0x7fff000071e7048b)),
                          vcreate_s16(UINT64_C(0xffff800080000000)));
      arg2 = 32767;
      clear_neon_saturated();
      //  Expect: "result" = ffff8001c0008000c000800000000000
      result = vmull_high_n_s16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 0);
         exp = UINT64_C(0xc000800000000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 1);
         exp = UINT64_C(0xffff8001c0008000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2331() {

{
   {
      int32x4_t arg1;
      int32_t arg2;
      int64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"mul\", fnname = \"vmull_high_n_s32\", rettype = \"int64x2_t\", argtypes = \"[int32x4_t,int32_t]\", vals = [VectorVal [IntegerVal (-1150287873),IntegerVal (-32769),IntegerVal 2147450879,IntegerVal 2147455764],IntegerVal (-2147483648)], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s32(vcreate_s32(UINT64_C(0xffff7fffbb6fffff)),
                          vcreate_s32(UINT64_C(0x7fff93147fff7fff)));
      arg2 = (int32_t) 0x80000000;
      clear_neon_saturated();
      //  Expect: "result" = c000367600000000c000400080000000
      result = vmull_high_n_s32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 0);
         exp = UINT64_C(0xc000400080000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 1);
         exp = UINT64_C(0xc000367600000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2332() {

{
   {
      uint16x8_t arg1;
      uint16_t arg2;
      uint32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"mul\", fnname = \"vmull_high_n_u16\", rettype = \"uint32x4_t\", argtypes = \"[uint16x8_t,uint16_t]\", vals = [VectorVal [IntegerVal 0,IntegerVal 32767,IntegerVal 32768,IntegerVal 21082,IntegerVal 65535,IntegerVal 0,IntegerVal 0,IntegerVal 0],IntegerVal 43007], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u16(vcreate_u16(UINT64_C(0x525a80007fff0000)),
                          vcreate_u16(UINT64_C(0x000000000000ffff)));
      arg2 = 43007U;
      clear_neon_saturated();
      //  Expect: "result" = 000000000000000000000000a7fe5801
      result = vmull_high_n_u16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 0);
         exp = UINT64_C(0x00000000a7fe5801);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 1);
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2333() {

{
   {
      uint32x4_t arg1;
      uint32_t arg2;
      uint64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"mul\", fnname = \"vmull_high_n_u32\", rettype = \"uint64x2_t\", argtypes = \"[uint32x4_t,uint32_t]\", vals = [VectorVal [IntegerVal 4294901760,IntegerVal 4294934528,IntegerVal 2147483647,IntegerVal 4294906015],IntegerVal 3397058560], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u32(vcreate_u32(UINT64_C(0xffff8000ffff0000)),
                          vcreate_u32(UINT64_C(0xffff109f7fffffff)));
      arg2 = 3397058560U;
      clear_neon_saturated();
      //  Expect: "result" = ca7a42aa72650000653d7fff35850000
      result = vmull_high_n_u32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 0);
         exp = UINT64_C(0x653d7fff35850000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 1);
         exp = UINT64_C(0xca7a42aa72650000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2334() {

{
   {
      int16x4_t arg1;
      int16_t arg2;
      int32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"qdmul\", fnname = \"vqdmull_n_s16\", rettype = \"int32x4_t\", argtypes = \"[int16x4_t,int16_t]\", vals = [VectorVal [IntegerVal 32767,IntegerVal (-1829),IntegerVal 700,IntegerVal 0],IntegerVal (-32768)], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_s16(UINT64_C(0x000002bcf8db7fff));
      arg2 = -32768;
      clear_neon_saturated();
      //  Expect: "result" = 00000000fd4400000725000080010000
      result = vqdmull_n_s16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 0);
         exp = UINT64_C(0x0725000080010000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 1);
         exp = UINT64_C(0x00000000fd440000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2335() {

{
   {
      int32x2_t arg1;
      int32_t arg2;
      int64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"qdmul\", fnname = \"vqdmull_n_s32\", rettype = \"int64x2_t\", argtypes = \"[int32x2_t,int32_t]\", vals = [VectorVal [IntegerVal (-65536),IntegerVal 2147418112],IntegerVal (-2147450880)], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_s32(UINT64_C(0x7fff0000ffff0000));
      arg2 = -2147450880;
      clear_neon_saturated();
      //  Expect: "result" = 80017fff000000000000ffff00000000
      result = vqdmull_n_s32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 0);
         exp = UINT64_C(0x0000ffff00000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 1);
         exp = UINT64_C(0x80017fff00000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2336() {

{
   {
      int16x8_t arg1;
      int16_t arg2;
      int32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"qdmul\", fnname = \"vqdmull_high_n_s16\", rettype = \"int32x4_t\", argtypes = \"[int16x8_t,int16_t]\", vals = [VectorVal [IntegerVal 32767,IntegerVal 32767,IntegerVal (-1),IntegerVal (-32768),IntegerVal 0,IntegerVal 32767,IntegerVal 32767,IntegerVal 32767],IntegerVal (-32768)], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s16(vcreate_s16(UINT64_C(0x8000ffff7fff7fff)),
                          vcreate_s16(UINT64_C(0x7fff7fff7fff0000)));
      arg2 = -32768;
      clear_neon_saturated();
      //  Expect: "result" = 80010000800100008001000000000000
      result = vqdmull_high_n_s16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 0);
         exp = UINT64_C(0x8001000000000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 1);
         exp = UINT64_C(0x8001000080010000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2337() {

{
   {
      int32x4_t arg1;
      int32_t arg2;
      int64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"qdmul\", fnname = \"vqdmull_high_n_s32\", rettype = \"int64x2_t\", argtypes = \"[int32x4_t,int32_t]\", vals = [VectorVal [IntegerVal (-2147454669),IntegerVal 65535,IntegerVal 65535,IntegerVal (-468418561)],IntegerVal (-44522)], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s32(vcreate_s32(UINT64_C(0x0000ffff80007133)),
                          vcreate_s32(UINT64_C(0xe4147fff0000ffff)));
      arg2 = -44522;
      clear_neon_saturated();
      //  Expect: "result" = 000025ef55875bd4fffffffea42d5bd4
      result = vqdmull_high_n_s32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 0);
         exp = UINT64_C(0xfffffffea42d5bd4);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 1);
         exp = UINT64_C(0x000025ef55875bd4);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2338() {

{
   {
      int16x4_t arg1;
      int16x4_t arg2;
      int32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"qdmul_lane\", fnname = \"vqdmull_lane_s16\", rettype = \"int32x4_t\", argtypes = \"[int16x4_t,int16x4_t,__constrange(0,3) int]\", vals = [VectorVal [IntegerVal (-1),IntegerVal 0,IntegerVal 32767,IntegerVal 32767],VectorVal [IntegerVal 32767,IntegerVal (-32768),IntegerVal 0,IntegerVal 32767],IndexVal 0], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_s16(UINT64_C(0x7fff7fff0000ffff));
      arg2 = vcreate_s16(UINT64_C(0x7fff000080007fff));
      clear_neon_saturated();
      //  Expect: "result" = 7ffe00027ffe000200000000ffff0002
      result = vqdmull_lane_s16(arg1, arg2, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 0);
         exp = UINT64_C(0x00000000ffff0002);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 1);
         exp = UINT64_C(0x7ffe00027ffe0002);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2339() {

{
   {
      int16x4_t arg1;
      int16x8_t arg2;
      int32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"qdmul_lane\", fnname = \"vqdmull_laneq_s16\", rettype = \"int32x4_t\", argtypes = \"[int16x4_t,int16x8_t,__constrange(0,7) int]\", vals = [VectorVal [IntegerVal (-1),IntegerVal 18832,IntegerVal 32767,IntegerVal (-32768)],VectorVal [IntegerVal 0,IntegerVal (-32768),IntegerVal 0,IntegerVal (-12992),IntegerVal 32767,IntegerVal 0,IntegerVal 0,IntegerVal 0],IndexVal 5], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_s16(UINT64_C(0x80007fff4990ffff));
      arg2 = vcombine_s16(vcreate_s16(UINT64_C(0xcd40000080000000)),
                          vcreate_s16(UINT64_C(0x0000000000007fff)));
      clear_neon_saturated();
      //  Expect: "result" = 00000000000000000000000000000000
      result = vqdmull_laneq_s16(arg1, arg2, 5);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 0);
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 1);
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2340() {

{
   {
      int32x2_t arg1;
      int32x2_t arg2;
      int64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"qdmul_lane\", fnname = \"vqdmull_lane_s32\", rettype = \"int64x2_t\", argtypes = \"[int32x2_t,int32x2_t,__constrange(0,1) int]\", vals = [VectorVal [IntegerVal 65535,IntegerVal 1680015360],VectorVal [IntegerVal 62391,IntegerVal 1831993344],IndexVal 1], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_s32(UINT64_C(0x642300000000ffff));
      arg2 = vcreate_s32(UINT64_C(0x6d3200000000f3b7));
      clear_neon_saturated();
      //  Expect: "result" = 556cebac000000000000da63259c0000
      result = vqdmull_lane_s32(arg1, arg2, 1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 0);
         exp = UINT64_C(0x0000da63259c0000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 1);
         exp = UINT64_C(0x556cebac00000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2341() {

{
   {
      int32x2_t arg1;
      int32x4_t arg2;
      int64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"qdmul_lane\", fnname = \"vqdmull_laneq_s32\", rettype = \"int64x2_t\", argtypes = \"[int32x2_t,int32x4_t,__constrange(0,3) int]\", vals = [VectorVal [IntegerVal 59211776,IntegerVal 65535],VectorVal [IntegerVal (-32768),IntegerVal (-1),IntegerVal 2147457174,IntegerVal 2147483647],IndexVal 1], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_s32(UINT64_C(0x0000ffff03878000));
      arg2 = vcombine_s32(vcreate_s32(UINT64_C(0xffffffffffff8000)),
                          vcreate_s32(UINT64_C(0x7fffffff7fff9896)));
      clear_neon_saturated();
      //  Expect: "result" = fffffffffffe0002fffffffff8f10000
      result = vqdmull_laneq_s32(arg1, arg2, 1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 0);
         exp = UINT64_C(0xfffffffff8f10000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 1);
         exp = UINT64_C(0xfffffffffffe0002);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2342() {

{
   {
      int16_t arg1;
      int16x4_t arg2;
      int32_t result;
      char* str1 = "ReproInfo2 {semantics = \"qdmul_lane\", fnname = \"vqdmullh_lane_s16\", rettype = \"int32_t\", argtypes = \"[int16_t,int16x4_t,__constrange(0,3) int]\", vals = [IntegerVal (-1),VectorVal [IntegerVal (-25369),IntegerVal (-32768),IntegerVal 0,IntegerVal 0],IndexVal 1], start_saturated = False}";
      int reported = 0;
      int32_t got;
      int32_t exp;
      arg1 = -1;
      arg2 = vcreate_s16(UINT64_C(0x0000000080009ce7));
      clear_neon_saturated();
      //  Expect: "result" = 00010000
      result = vqdmullh_lane_s16(arg1, arg2, 1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = 65536;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIi32 " Got: %" PRIi32 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2343() {

{
   {
      int16_t arg1;
      int16x8_t arg2;
      int32_t result;
      char* str1 = "ReproInfo2 {semantics = \"qdmul_lane\", fnname = \"vqdmullh_laneq_s16\", rettype = \"int32_t\", argtypes = \"[int16_t,int16x8_t,__constrange(0,7) int]\", vals = [IntegerVal (-32768),VectorVal [IntegerVal (-1),IntegerVal 0,IntegerVal 0,IntegerVal (-32768),IntegerVal (-1),IntegerVal (-1),IntegerVal (-32768),IntegerVal (-32768)],IndexVal 6], start_saturated = False}";
      int reported = 0;
      int32_t got;
      int32_t exp;
      arg1 = -32768;
      arg2 = vcombine_s16(vcreate_s16(UINT64_C(0x800000000000ffff)),
                          vcreate_s16(UINT64_C(0x80008000ffffffff)));
      clear_neon_saturated();
      //  Expect: "result" = 7fffffff
      result = vqdmullh_laneq_s16(arg1, arg2, 6);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      got = result;
      exp = 2147483647;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIi32 " Got: %" PRIi32 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2344() {

{
   {
      int32_t arg1;
      int32x2_t arg2;
      int64_t result;
      char* str1 = "ReproInfo2 {semantics = \"qdmul_lane\", fnname = \"vqdmulls_lane_s32\", rettype = \"int64_t\", argtypes = \"[int32_t,int32x2_t,__constrange(0,1) int]\", vals = [IntegerVal (-26447),VectorVal [IntegerVal (-2147450881),IntegerVal (-1656651776)],IndexVal 1], start_saturated = True}";
      int reported = 0;
      int64_t got;
      int64_t exp;
      arg1 = -26447;
      arg2 = vcreate_s32(UINT64_C(0x9d41800080007fff));
      set_neon_saturated();
      //  Expect: "result" = 00004fb23c930000
      result = vqdmulls_lane_s32(arg1, arg2, 1);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      got = result;
      exp = INT64_C(87626939039744);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIi64 " Got: %" PRIi64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2345() {

{
   {
      int32_t arg1;
      int32x4_t arg2;
      int64_t result;
      char* str1 = "ReproInfo2 {semantics = \"qdmul_lane\", fnname = \"vqdmulls_laneq_s32\", rettype = \"int64_t\", argtypes = \"[int32_t,int32x4_t,__constrange(0,3) int]\", vals = [IntegerVal 2147450879,VectorVal [IntegerVal (-16729),IntegerVal 12338,IntegerVal (-65536),IntegerVal (-2147450881)],IndexVal 0], start_saturated = False}";
      int reported = 0;
      int64_t got;
      int64_t exp;
      arg1 = 2147450879;
      arg2 = vcombine_s32(vcreate_s32(UINT64_C(0x00003032ffffbea7)),
                          vcreate_s32(UINT64_C(0x80007fffffff0000)));
      clear_neon_saturated();
      //  Expect: "result" = ffffbea7415982b2
      result = vqdmulls_laneq_s32(arg1, arg2, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = INT64_C(-71849411509582);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIi64 " Got: %" PRIi64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2346() {

{
   {
      int16x8_t arg1;
      int16x4_t arg2;
      int32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"qdmul_lane\", fnname = \"vqdmull_high_lane_s16\", rettype = \"int32x4_t\", argtypes = \"[int16x8_t,int16x4_t,__constrange(0,3) int]\", vals = [VectorVal [IntegerVal 0,IntegerVal 0,IntegerVal 32767,IntegerVal 32767,IntegerVal 26797,IntegerVal 0,IntegerVal 14343,IntegerVal (-1)],VectorVal [IntegerVal 32767,IntegerVal (-1),IntegerVal (-1),IntegerVal (-1)],IndexVal 3], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s16(vcreate_s16(UINT64_C(0x7fff7fff00000000)),
                          vcreate_s16(UINT64_C(0xffff3807000068ad)));
      arg2 = vcreate_s16(UINT64_C(0xffffffffffff7fff));
      clear_neon_saturated();
      //  Expect: "result" = 00000002ffff8ff200000000ffff2ea6
      result = vqdmull_high_lane_s16(arg1, arg2, 3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 0);
         exp = UINT64_C(0x00000000ffff2ea6);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 1);
         exp = UINT64_C(0x00000002ffff8ff2);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2347() {

{
   {
      int16x8_t arg1;
      int16x8_t arg2;
      int32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"qdmul_lane\", fnname = \"vqdmull_high_laneq_s16\", rettype = \"int32x4_t\", argtypes = \"[int16x8_t,int16x8_t,__constrange(0,7) int]\", vals = [VectorVal [IntegerVal 32767,IntegerVal 32767,IntegerVal (-1),IntegerVal 0,IntegerVal 32767,IntegerVal (-1),IntegerVal 0,IntegerVal (-1)],VectorVal [IntegerVal 32767,IntegerVal 0,IntegerVal (-1),IntegerVal 0,IntegerVal (-1),IntegerVal 9211,IntegerVal 0,IntegerVal 32767],IndexVal 5], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s16(vcreate_s16(UINT64_C(0x0000ffff7fff7fff)),
                          vcreate_s16(UINT64_C(0xffff0000ffff7fff)));
      arg2 = vcombine_s16(vcreate_s16(UINT64_C(0x0000ffff00007fff)),
                          vcreate_s16(UINT64_C(0x7fff000023fbffff)));
      clear_neon_saturated();
      //  Expect: "result" = ffffb80a00000000ffffb80a23fab80a
      result = vqdmull_high_laneq_s16(arg1, arg2, 5);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 0);
         exp = UINT64_C(0xffffb80a23fab80a);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 1);
         exp = UINT64_C(0xffffb80a00000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2348() {

{
   {
      int32x4_t arg1;
      int32x2_t arg2;
      int64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"qdmul_lane\", fnname = \"vqdmull_high_lane_s32\", rettype = \"int64x2_t\", argtypes = \"[int32x4_t,int32x2_t,__constrange(0,1) int]\", vals = [VectorVal [IntegerVal 2147456633,IntegerVal (-2147418113),IntegerVal (-2147483648),IntegerVal 1846280192],VectorVal [IntegerVal 2147450879,IntegerVal (-2147450881)],IndexVal 0], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s32(vcreate_s32(UINT64_C(0x8000ffff7fff9679)),
                          vcreate_s32(UINT64_C(0x6e0c000080000000)));
      arg2 = vcreate_s32(UINT64_C(0x80007fff7fff7fff));
      clear_neon_saturated();
      //  Expect: "result" = 6e0b91f323e800008000800100000000
      result = vqdmull_high_lane_s32(arg1, arg2, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 0);
         exp = UINT64_C(0x8000800100000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 1);
         exp = UINT64_C(0x6e0b91f323e80000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2349() {

{
   {
      int32x4_t arg1;
      int32x4_t arg2;
      int64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"qdmul_lane\", fnname = \"vqdmull_high_laneq_s32\", rettype = \"int64x2_t\", argtypes = \"[int32x4_t,int32x4_t,__constrange(0,3) int]\", vals = [VectorVal [IntegerVal (-2147465841),IntegerVal 2147450879,IntegerVal 2147450879,IntegerVal (-1)],VectorVal [IntegerVal (-819233356),IntegerVal 2147456576,IntegerVal 65535,IntegerVal 0],IndexVal 1], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s32(vcreate_s32(UINT64_C(0x7fff7fff8000458f)),
                          vcreate_s32(UINT64_C(0xffffffff7fff7fff)));
      arg2 = vcombine_s32(vcreate_s32(UINT64_C(0x7fff9640cf2b7db4)),
                          vcreate_s32(UINT64_C(0x000000000000ffff)));
      clear_neon_saturated();
      //  Expect: "result" = ffffffff0000d3807fff163f69c0d380
      result = vqdmull_high_laneq_s32(arg1, arg2, 1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 0);
         exp = UINT64_C(0x7fff163f69c0d380);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 1);
         exp = UINT64_C(0xffffffff0000d380);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2350() {

{
   {
      int16x4_t arg1;
      int16_t arg2;
      int16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"qdmlh\", fnname = \"vqdmulh_n_s16\", rettype = \"int16x4_t\", argtypes = \"[int16x4_t,int16_t]\", vals = [VectorVal [IntegerVal (-32768),IntegerVal 32767,IntegerVal 32767,IntegerVal 0],IntegerVal (-32768)], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s16(UINT64_C(0x00007fff7fff8000));
      arg2 = -32768;
      clear_neon_saturated();
      //  Expect: "result" = 0000800180017fff
      result = vqdmulh_n_s16(arg1, arg2);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s16(result), 0);
      exp = UINT64_C(0x0000800180017fff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2351() {

{
   {
      int32x2_t arg1;
      int32_t arg2;
      int32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"qdmlh\", fnname = \"vqdmulh_n_s32\", rettype = \"int32x2_t\", argtypes = \"[int32x2_t,int32_t]\", vals = [VectorVal [IntegerVal 459333954,IntegerVal 2147450879],IntegerVal 2147479874], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s32(UINT64_C(0x7fff7fff1b60e142));
      arg2 = 2147479874;
      clear_neon_saturated();
      //  Expect: "result" = 7fff71411b60de1a
      result = vqdmulh_n_s32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s32(result), 0);
      exp = UINT64_C(0x7fff71411b60de1a);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2352() {

{
   {
      int16x8_t arg1;
      int16_t arg2;
      int16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"qdmlh\", fnname = \"vqdmulhq_n_s16\", rettype = \"int16x8_t\", argtypes = \"[int16x8_t,int16_t]\", vals = [VectorVal [IntegerVal (-1),IntegerVal 0,IntegerVal (-32768),IntegerVal 3749,IntegerVal 14980,IntegerVal (-1),IntegerVal (-1),IntegerVal (-32768)],IntegerVal (-15129)], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s16(vcreate_s16(UINT64_C(0x0ea580000000ffff)),
                          vcreate_s16(UINT64_C(0x8000ffffffff3a84)));
      arg2 = -15129;
      clear_neon_saturated();
      //  Expect: "result" = 3b1900000000e4fbf93d3b1900000000
      result = vqdmulhq_n_s16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 0);
         exp = UINT64_C(0xf93d3b1900000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 1);
         exp = UINT64_C(0x3b1900000000e4fb);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2353() {

{
   {
      int32x4_t arg1;
      int32_t arg2;
      int32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"qdmlh\", fnname = \"vqdmulhq_n_s32\", rettype = \"int32x4_t\", argtypes = \"[int32x4_t,int32_t]\", vals = [VectorVal [IntegerVal (-2147450881),IntegerVal (-943521793),IntegerVal 65535,IntegerVal 32768],IntegerVal 2147483647], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s32(vcreate_s32(UINT64_C(0xc7c2ffff80007fff)),
                          vcreate_s32(UINT64_C(0x000080000000ffff)));
      arg2 = 2147483647;
      clear_neon_saturated();
      //  Expect: "result" = 00007fff0000fffec7c2ffff80007fff
      result = vqdmulhq_n_s32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 0);
         exp = UINT64_C(0xc7c2ffff80007fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 1);
         exp = UINT64_C(0x00007fff0000fffe);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2354() {

{
   {
      int16x4_t arg1;
      int16x4_t arg2;
      int16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"qdmlh_lane\", fnname = \"vqdmulh_lane_s16\", rettype = \"int16x4_t\", argtypes = \"[int16x4_t,int16x4_t,__constrange(0,3) int]\", vals = [VectorVal [IntegerVal (-9779),IntegerVal 0,IntegerVal (-32768),IntegerVal (-25443)],VectorVal [IntegerVal (-32768),IntegerVal (-32768),IntegerVal (-1),IntegerVal (-32768)],IndexVal 2], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s16(UINT64_C(0x9c9d80000000d9cd));
      arg2 = vcreate_s16(UINT64_C(0x8000ffff80008000));
      clear_neon_saturated();
      //  Expect: "result" = 0000000100000000
      result = vqdmulh_lane_s16(arg1, arg2, 2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s16(result), 0);
      exp = UINT64_C(0x0000000100000000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2355() {

{
   {
      int16x4_t arg1;
      int16x8_t arg2;
      int16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"qdmlh_lane\", fnname = \"vqdmulh_laneq_s16\", rettype = \"int16x4_t\", argtypes = \"[int16x4_t,int16x8_t,__constrange(0,7) int]\", vals = [VectorVal [IntegerVal (-32768),IntegerVal 0,IntegerVal 0,IntegerVal (-32768)],VectorVal [IntegerVal 0,IntegerVal (-32768),IntegerVal (-32768),IntegerVal (-32768),IntegerVal (-1),IntegerVal (-32768),IntegerVal 32767,IntegerVal (-32768)],IndexVal 5], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s16(UINT64_C(0x8000000000008000));
      arg2 = vcombine_s16(vcreate_s16(UINT64_C(0x8000800080000000)),
                          vcreate_s16(UINT64_C(0x80007fff8000ffff)));
      clear_neon_saturated();
      //  Expect: "result" = 7fff000000007fff
      result = vqdmulh_laneq_s16(arg1, arg2, 5);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s16(result), 0);
      exp = UINT64_C(0x7fff000000007fff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2356() {

{
   {
      int32x2_t arg1;
      int32x2_t arg2;
      int32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"qdmlh_lane\", fnname = \"vqdmulh_lane_s32\", rettype = \"int32x2_t\", argtypes = \"[int32x2_t,int32x2_t,__constrange(0,1) int]\", vals = [VectorVal [IntegerVal 32767,IntegerVal 2147450880],VectorVal [IntegerVal 924811264,IntegerVal (-32769)],IndexVal 0], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s32(UINT64_C(0x7fff800000007fff));
      arg2 = vcreate_s32(UINT64_C(0xffff7fff371f8000));
      clear_neon_saturated();
      //  Expect: "result" = 371f48e00000371f
      result = vqdmulh_lane_s32(arg1, arg2, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s32(result), 0);
      exp = UINT64_C(0x371f48e00000371f);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2357() {

{
   {
      int32x2_t arg1;
      int32x4_t arg2;
      int32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"qdmlh_lane\", fnname = \"vqdmulh_laneq_s32\", rettype = \"int32x2_t\", argtypes = \"[int32x2_t,int32x4_t,__constrange(0,3) int]\", vals = [VectorVal [IntegerVal (-441810945),IntegerVal 65535],VectorVal [IntegerVal (-1290108929),IntegerVal (-32769),IntegerVal 2147450879,IntegerVal 2147418112],IndexVal 2], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s32(UINT64_C(0x0000ffffe5aa7fff));
      arg2 = vcombine_s32(vcreate_s32(UINT64_C(0xffff7fffb31a7fff)),
                          vcreate_s32(UINT64_C(0x7fff00007fff7fff)));
      clear_neon_saturated();
      //  Expect: "result" = 0000fffde5aa9a54
      result = vqdmulh_laneq_s32(arg1, arg2, 2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s32(result), 0);
      exp = UINT64_C(0x0000fffde5aa9a54);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2358() {

{
   {
      int16x8_t arg1;
      int16x4_t arg2;
      int16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"qdmlh_lane\", fnname = \"vqdmulhq_lane_s16\", rettype = \"int16x8_t\", argtypes = \"[int16x8_t,int16x4_t,__constrange(0,3) int]\", vals = [VectorVal [IntegerVal 28223,IntegerVal 18103,IntegerVal (-7157),IntegerVal (-20443),IntegerVal (-1),IntegerVal (-32768),IntegerVal (-32768),IntegerVal 0],VectorVal [IntegerVal 15173,IntegerVal (-25231),IntegerVal 10380,IntegerVal 0],IndexVal 2], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s16(vcreate_s16(UINT64_C(0xb025e40b46b76e3f)),
                          vcreate_s16(UINT64_C(0x000080008000ffff)));
      arg2 = vcreate_s16(UINT64_C(0x0000288c9d713b45));
      clear_neon_saturated();
      //  Expect: "result" = 0000d774d774ffffe6b4f724166622ec
      result = vqdmulhq_lane_s16(arg1, arg2, 2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 0);
         exp = UINT64_C(0xe6b4f724166622ec);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 1);
         exp = UINT64_C(0x0000d774d774ffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2359() {

{
   {
      int16x8_t arg1;
      int16x8_t arg2;
      int16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"qdmlh_lane\", fnname = \"vqdmulhq_laneq_s16\", rettype = \"int16x8_t\", argtypes = \"[int16x8_t,int16x8_t,__constrange(0,7) int]\", vals = [VectorVal [IntegerVal (-1),IntegerVal 0,IntegerVal (-1),IntegerVal 32767,IntegerVal 0,IntegerVal (-32768),IntegerVal 0,IntegerVal (-1)],VectorVal [IntegerVal 13109,IntegerVal 32767,IntegerVal 32767,IntegerVal 0,IntegerVal (-21891),IntegerVal 32733,IntegerVal (-1),IntegerVal (-1)],IndexVal 5], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s16(vcreate_s16(UINT64_C(0x7fffffff0000ffff)),
                          vcreate_s16(UINT64_C(0xffff000080000000)));
      arg2 = vcombine_s16(vcreate_s16(UINT64_C(0x00007fff7fff3335)),
                          vcreate_s16(UINT64_C(0xffffffff7fddaa7d)));
      clear_neon_saturated();
      //  Expect: "result" = ffff0000802300007fdcffff0000ffff
      result = vqdmulhq_laneq_s16(arg1, arg2, 5);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 0);
         exp = UINT64_C(0x7fdcffff0000ffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 1);
         exp = UINT64_C(0xffff000080230000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2360() {

{
   {
      int32x4_t arg1;
      int32x2_t arg2;
      int32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"qdmlh_lane\", fnname = \"vqdmulhq_lane_s32\", rettype = \"int32x4_t\", argtypes = \"[int32x4_t,int32x2_t,__constrange(0,1) int]\", vals = [VectorVal [IntegerVal 2147473140,IntegerVal (-65536),IntegerVal (-1),IntegerVal 53876],VectorVal [IntegerVal 2147439086,IntegerVal (-2147418113)],IndexVal 0], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s32(vcreate_s32(UINT64_C(0xffff00007fffd6f4)),
                          vcreate_s32(UINT64_C(0x0000d274ffffffff)));
      arg2 = vcreate_s32(UINT64_C(0x8000ffff7fff51ee));
      clear_neon_saturated();
      //  Expect: "result" = 0000d272ffffffffffff00017fff28e2
      result = vqdmulhq_lane_s32(arg1, arg2, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 0);
         exp = UINT64_C(0xffff00017fff28e2);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 1);
         exp = UINT64_C(0x0000d272ffffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2361() {

{
   {
      int32x4_t arg1;
      int32x4_t arg2;
      int32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"qdmlh_lane\", fnname = \"vqdmulhq_laneq_s32\", rettype = \"int32x4_t\", argtypes = \"[int32x4_t,int32x4_t,__constrange(0,3) int]\", vals = [VectorVal [IntegerVal 2147418112,IntegerVal 2147462189,IntegerVal (-32768),IntegerVal (-2147483648)],VectorVal [IntegerVal 2147450879,IntegerVal 2147450879,IntegerVal 2147418112,IntegerVal 1860665343],IndexVal 0], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s32(vcreate_s32(UINT64_C(0x7fffac2d7fff0000)),
                          vcreate_s32(UINT64_C(0x80000000ffff8000)));
      arg2 = vcombine_s32(vcreate_s32(UINT64_C(0x7fff7fff7fff7fff)),
                          vcreate_s32(UINT64_C(0x6ee77fff7fff0000)));
      clear_neon_saturated();
      //  Expect: "result" = 80008001ffff80007fff2c2c7ffe8000
      result = vqdmulhq_laneq_s32(arg1, arg2, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 0);
         exp = UINT64_C(0x7fff2c2c7ffe8000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 1);
         exp = UINT64_C(0x80008001ffff8000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2362() {

{
   {
      int16_t arg1;
      int16x4_t arg2;
      int16_t result;
      char* str1 = "ReproInfo2 {semantics = \"qdmlh_lane\", fnname = \"vqdmulhh_lane_s16\", rettype = \"int16_t\", argtypes = \"[int16_t,int16x4_t,__constrange(0,3) int]\", vals = [IntegerVal 32767,VectorVal [IntegerVal 32767,IntegerVal 32767,IntegerVal 0,IntegerVal (-1)],IndexVal 1], start_saturated = False}";
      int reported = 0;
      int16_t got;
      int16_t exp;
      arg1 = 32767;
      arg2 = vcreate_s16(UINT64_C(0xffff00007fff7fff));
      clear_neon_saturated();
      //  Expect: "result" = 7ffe
      result = vqdmulhh_lane_s16(arg1, arg2, 1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = 32766;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIi16 " Got: %" PRIi16 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2363() {

{
   {
      int16_t arg1;
      int16x8_t arg2;
      int16_t result;
      char* str1 = "ReproInfo2 {semantics = \"qdmlh_lane\", fnname = \"vqdmulhh_laneq_s16\", rettype = \"int16_t\", argtypes = \"[int16_t,int16x8_t,__constrange(0,7) int]\", vals = [IntegerVal (-1),VectorVal [IntegerVal (-1),IntegerVal (-1),IntegerVal (-32768),IntegerVal 32767,IntegerVal 32767,IntegerVal 32767,IntegerVal (-32768),IntegerVal 14799],IndexVal 0], start_saturated = False}";
      int reported = 0;
      int16_t got;
      int16_t exp;
      arg1 = -1;
      arg2 = vcombine_s16(vcreate_s16(UINT64_C(0x7fff8000ffffffff)),
                          vcreate_s16(UINT64_C(0x39cf80007fff7fff)));
      clear_neon_saturated();
      //  Expect: "result" = 0000
      result = vqdmulhh_laneq_s16(arg1, arg2, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = 0;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIi16 " Got: %" PRIi16 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2364() {

{
   {
      int32_t arg1;
      int32x2_t arg2;
      int32_t result;
      char* str1 = "ReproInfo2 {semantics = \"qdmlh_lane\", fnname = \"vqdmulhs_lane_s32\", rettype = \"int32_t\", argtypes = \"[int32_t,int32x2_t,__constrange(0,1) int]\", vals = [IntegerVal (-780590395),VectorVal [IntegerVal (-65536),IntegerVal 2147418112],IndexVal 1], start_saturated = False}";
      int reported = 0;
      int32_t got;
      int32_t exp;
      arg1 = -780590395;
      arg2 = vcreate_s32(UINT64_C(0x7fff0000ffff0000));
      clear_neon_saturated();
      //  Expect: "result" = d1797fd2
      result = vqdmulhs_lane_s32(arg1, arg2, 1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = -780566574;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIi32 " Got: %" PRIi32 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2365() {

{
   {
      int32_t arg1;
      int32x4_t arg2;
      int32_t result;
      char* str1 = "ReproInfo2 {semantics = \"qdmlh_lane\", fnname = \"vqdmulhs_laneq_s32\", rettype = \"int32_t\", argtypes = \"[int32_t,int32x4_t,__constrange(0,3) int]\", vals = [IntegerVal (-1737926348),VectorVal [IntegerVal (-2147483648),IntegerVal 32767,IntegerVal (-32768),IntegerVal (-2147418113)],IndexVal 0], start_saturated = True}";
      int reported = 0;
      int32_t got;
      int32_t exp;
      arg1 = -1737926348;
      arg2 = vcombine_s32(vcreate_s32(UINT64_C(0x00007fff80000000)),
                          vcreate_s32(UINT64_C(0x8000ffffffff8000)));
      set_neon_saturated();
      //  Expect: "result" = 6796a6cc
      result = vqdmulhs_laneq_s32(arg1, arg2, 0);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      got = result;
      exp = 1737926348;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIi32 " Got: %" PRIi32 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2366() {

{
   {
      int16x4_t arg1;
      int16_t arg2;
      int16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"qrdmlh\", fnname = \"vqrdmulh_n_s16\", rettype = \"int16x4_t\", argtypes = \"[int16x4_t,int16_t]\", vals = [VectorVal [IntegerVal 18388,IntegerVal 0,IntegerVal 26983,IntegerVal (-1582)],IntegerVal (-1)], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s16(UINT64_C(0xf9d26967000047d4));
      arg2 = -1;
      clear_neon_saturated();
      //  Expect: "result" = 0000ffff0000ffff
      result = vqrdmulh_n_s16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s16(result), 0);
      exp = UINT64_C(0x0000ffff0000ffff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2367() {

{
   {
      int32x2_t arg1;
      int32_t arg2;
      int32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"qrdmlh\", fnname = \"vqrdmulh_n_s32\", rettype = \"int32x2_t\", argtypes = \"[int32x2_t,int32_t]\", vals = [VectorVal [IntegerVal 89489408,IntegerVal (-2107768832)],IntegerVal 2147450879], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s32(UINT64_C(0x825e000005558000));
      arg2 = 2147450879;
      clear_neon_saturated();
      //  Expect: "result" = 825e7da305557aaa
      result = vqrdmulh_n_s32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s32(result), 0);
      exp = UINT64_C(0x825e7da305557aaa);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2368() {

{
   {
      int16x8_t arg1;
      int16_t arg2;
      int16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"qrdmlh\", fnname = \"vqrdmulhq_n_s16\", rettype = \"int16x8_t\", argtypes = \"[int16x8_t,int16_t]\", vals = [VectorVal [IntegerVal (-1),IntegerVal (-1),IntegerVal (-1),IntegerVal 0,IntegerVal 0,IntegerVal (-32768),IntegerVal (-1),IntegerVal (-1)],IntegerVal (-32768)], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s16(vcreate_s16(UINT64_C(0x0000ffffffffffff)),
                          vcreate_s16(UINT64_C(0xffffffff80000000)));
      arg2 = -32768;
      clear_neon_saturated();
      //  Expect: "result" = 000100017fff00000000000100010001
      result = vqrdmulhq_n_s16(arg1, arg2);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 0);
         exp = UINT64_C(0x0000000100010001);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 1);
         exp = UINT64_C(0x000100017fff0000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2369() {

{
   {
      int32x4_t arg1;
      int32_t arg2;
      int32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"qrdmlh\", fnname = \"vqrdmulhq_n_s32\", rettype = \"int32x4_t\", argtypes = \"[int32x4_t,int32_t]\", vals = [VectorVal [IntegerVal 1542258687,IntegerVal 2147483647,IntegerVal 32767,IntegerVal 2147450880],IntegerVal 2060921098], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s32(vcreate_s32(UINT64_C(0x7fffffff5becffff)),
                          vcreate_s32(UINT64_C(0x7fff800000007fff)));
      arg2 = 2060921098;
      clear_neon_saturated();
      //  Expect: "result" = 7ad6ae3300007ad67ad729095838698e
      result = vqrdmulhq_n_s32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 0);
         exp = UINT64_C(0x7ad729095838698e);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 1);
         exp = UINT64_C(0x7ad6ae3300007ad6);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2370() {

{
   {
      int16x4_t arg1;
      int16x4_t arg2;
      int16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"qrdmlh_lane\", fnname = \"vqrdmulh_lane_s16\", rettype = \"int16x4_t\", argtypes = \"[int16x4_t,int16x4_t,__constrange(0,3) int]\", vals = [VectorVal [IntegerVal 0,IntegerVal 0,IntegerVal (-22607),IntegerVal 0],VectorVal [IntegerVal 0,IntegerVal (-32768),IntegerVal (-32768),IntegerVal (-2996)],IndexVal 3], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s16(UINT64_C(0x0000a7b100000000));
      arg2 = vcreate_s16(UINT64_C(0xf44c800080000000));
      clear_neon_saturated();
      //  Expect: "result" = 0000081300000000
      result = vqrdmulh_lane_s16(arg1, arg2, 3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s16(result), 0);
      exp = UINT64_C(0x0000081300000000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2371() {

{
   {
      int16x4_t arg1;
      int16x8_t arg2;
      int16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"qrdmlh_lane\", fnname = \"vqrdmulh_laneq_s16\", rettype = \"int16x4_t\", argtypes = \"[int16x4_t,int16x8_t,__constrange(0,7) int]\", vals = [VectorVal [IntegerVal (-32768),IntegerVal 0,IntegerVal (-1),IntegerVal (-1914)],VectorVal [IntegerVal 1279,IntegerVal (-1),IntegerVal (-1),IntegerVal 0,IntegerVal (-32768),IntegerVal (-32768),IntegerVal (-1),IntegerVal (-1)],IndexVal 7], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s16(UINT64_C(0xf886ffff00008000));
      arg2 = vcombine_s16(vcreate_s16(UINT64_C(0x0000ffffffff04ff)),
                          vcreate_s16(UINT64_C(0xffffffff80008000)));
      clear_neon_saturated();
      //  Expect: "result" = 0000000000000001
      result = vqrdmulh_laneq_s16(arg1, arg2, 7);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s16(result), 0);
      exp = UINT64_C(0x0000000000000001);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2372() {

{
   {
      int32x2_t arg1;
      int32x2_t arg2;
      int32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"qrdmlh_lane\", fnname = \"vqrdmulh_lane_s32\", rettype = \"int32x2_t\", argtypes = \"[int32x2_t,int32x2_t,__constrange(0,1) int]\", vals = [VectorVal [IntegerVal 2147483647,IntegerVal 2147483647],VectorVal [IntegerVal 2147464112,IntegerVal (-1)],IndexVal 0], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s32(UINT64_C(0x7fffffff7fffffff));
      arg2 = vcreate_s32(UINT64_C(0xffffffff7fffb3b0));
      clear_neon_saturated();
      //  Expect: "result" = 7fffb3af7fffb3af
      result = vqrdmulh_lane_s32(arg1, arg2, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s32(result), 0);
      exp = UINT64_C(0x7fffb3af7fffb3af);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2373() {

{
   {
      int32x2_t arg1;
      int32x4_t arg2;
      int32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"qrdmlh_lane\", fnname = \"vqrdmulh_laneq_s32\", rettype = \"int32x2_t\", argtypes = \"[int32x2_t,int32x4_t,__constrange(0,3) int]\", vals = [VectorVal [IntegerVal (-2147450881),IntegerVal (-2147418113)],VectorVal [IntegerVal 15366,IntegerVal 32767,IntegerVal 2147418112,IntegerVal (-2147450881)],IndexVal 1], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s32(UINT64_C(0x8000ffff80007fff));
      arg2 = vcombine_s32(vcreate_s32(UINT64_C(0x00007fff00003c06)),
                          vcreate_s32(UINT64_C(0x80007fff7fff0000)));
      clear_neon_saturated();
      //  Expect: "result" = ffff8002ffff8001
      result = vqrdmulh_laneq_s32(arg1, arg2, 1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s32(result), 0);
      exp = UINT64_C(0xffff8002ffff8001);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2374() {

{
   {
      int16x8_t arg1;
      int16x4_t arg2;
      int16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"qrdmlh_lane\", fnname = \"vqrdmulhq_lane_s16\", rettype = \"int16x8_t\", argtypes = \"[int16x8_t,int16x4_t,__constrange(0,3) int]\", vals = [VectorVal [IntegerVal 0,IntegerVal 32767,IntegerVal (-32768),IntegerVal (-32768),IntegerVal 5674,IntegerVal (-32768),IntegerVal 32767,IntegerVal 8197],VectorVal [IntegerVal (-808),IntegerVal 0,IntegerVal (-1),IntegerVal (-32768)],IndexVal 2], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s16(vcreate_s16(UINT64_C(0x800080007fff0000)),
                          vcreate_s16(UINT64_C(0x20057fff8000162a)));
      arg2 = vcreate_s16(UINT64_C(0x8000ffff0000fcd8));
      clear_neon_saturated();
      //  Expect: "result" = 0000ffff0001000000010001ffff0000
      result = vqrdmulhq_lane_s16(arg1, arg2, 2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 0);
         exp = UINT64_C(0x00010001ffff0000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 1);
         exp = UINT64_C(0x0000ffff00010000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2375() {

{
   {
      int16x8_t arg1;
      int16x8_t arg2;
      int16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"qrdmlh_lane\", fnname = \"vqrdmulhq_laneq_s16\", rettype = \"int16x8_t\", argtypes = \"[int16x8_t,int16x8_t,__constrange(0,7) int]\", vals = [VectorVal [IntegerVal (-14535),IntegerVal (-1),IntegerVal (-1),IntegerVal (-32768),IntegerVal 32767,IntegerVal (-32768),IntegerVal 0,IntegerVal 0],VectorVal [IntegerVal (-27566),IntegerVal 3896,IntegerVal (-32768),IntegerVal (-32768),IntegerVal 0,IntegerVal 32767,IntegerVal (-32768),IntegerVal (-32768)],IndexVal 2], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s16(vcreate_s16(UINT64_C(0x8000ffffffffc739)),
                          vcreate_s16(UINT64_C(0x0000000080007fff)));
      arg2 = vcombine_s16(vcreate_s16(UINT64_C(0x800080000f389452)),
                          vcreate_s16(UINT64_C(0x800080007fff0000)));
      clear_neon_saturated();
      //  Expect: "result" = 000000007fff80017fff0001000138c7
      result = vqrdmulhq_laneq_s16(arg1, arg2, 2);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 0);
         exp = UINT64_C(0x7fff0001000138c7);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 1);
         exp = UINT64_C(0x000000007fff8001);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2376() {

{
   {
      int32x4_t arg1;
      int32x2_t arg2;
      int32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"qrdmlh_lane\", fnname = \"vqrdmulhq_lane_s32\", rettype = \"int32x4_t\", argtypes = \"[int32x4_t,int32x2_t,__constrange(0,1) int]\", vals = [VectorVal [IntegerVal 2147418112,IntegerVal (-1151631361),IntegerVal 32767,IntegerVal 2147418112],VectorVal [IntegerVal 65535,IntegerVal 1105526784],IndexVal 0], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s32(vcreate_s32(UINT64_C(0xbb5b7fff7fff0000)),
                          vcreate_s32(UINT64_C(0x7fff000000007fff)));
      arg2 = vcreate_s32(UINT64_C(0x41e500000000ffff));
      clear_neon_saturated();
      //  Expect: "result" = 0000fffd00000001ffff76b80000fffd
      result = vqrdmulhq_lane_s32(arg1, arg2, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 0);
         exp = UINT64_C(0xffff76b80000fffd);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 1);
         exp = UINT64_C(0x0000fffd00000001);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2377() {

{
   {
      int32x4_t arg1;
      int32x4_t arg2;
      int32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"qrdmlh_lane\", fnname = \"vqrdmulhq_laneq_s32\", rettype = \"int32x4_t\", argtypes = \"[int32x4_t,int32x4_t,__constrange(0,3) int]\", vals = [VectorVal [IntegerVal 2147483647,IntegerVal (-2147418113),IntegerVal (-2147450881),IntegerVal (-65536)],VectorVal [IntegerVal (-2105507840),IntegerVal (-2147450881),IntegerVal 2147464225,IntegerVal 34224],IndexVal 2], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s32(vcreate_s32(UINT64_C(0x8000ffff7fffffff)),
                          vcreate_s32(UINT64_C(0xffff000080007fff)));
      arg2 = vcombine_s32(vcreate_s32(UINT64_C(0x80007fff82808000)),
                          vcreate_s32(UINT64_C(0x000085b07fffb421)));
      clear_neon_saturated();
      //  Expect: "result" = ffff00018000cbde80014bdd7fffb420
      result = vqrdmulhq_laneq_s32(arg1, arg2, 2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 0);
         exp = UINT64_C(0x80014bdd7fffb420);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 1);
         exp = UINT64_C(0xffff00018000cbde);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2378() {

{
   {
      int16_t arg1;
      int16x4_t arg2;
      int16_t result;
      char* str1 = "ReproInfo2 {semantics = \"qrdmlh_lane\", fnname = \"vqrdmulhh_lane_s16\", rettype = \"int16_t\", argtypes = \"[int16_t,int16x4_t,__constrange(0,3) int]\", vals = [IntegerVal (-9426),VectorVal [IntegerVal 1719,IntegerVal (-1),IntegerVal (-1),IntegerVal 27961],IndexVal 1], start_saturated = False}";
      int reported = 0;
      int16_t got;
      int16_t exp;
      arg1 = -9426;
      arg2 = vcreate_s16(UINT64_C(0x6d39ffffffff06b7));
      clear_neon_saturated();
      //  Expect: "result" = 0000
      result = vqrdmulhh_lane_s16(arg1, arg2, 1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = 0;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIi16 " Got: %" PRIi16 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2379() {

{
   {
      int16_t arg1;
      int16x8_t arg2;
      int16_t result;
      char* str1 = "ReproInfo2 {semantics = \"qrdmlh_lane\", fnname = \"vqrdmulhh_laneq_s16\", rettype = \"int16_t\", argtypes = \"[int16_t,int16x8_t,__constrange(0,7) int]\", vals = [IntegerVal (-32768),VectorVal [IntegerVal 26607,IntegerVal (-1),IntegerVal (-30239),IntegerVal (-1),IntegerVal 30310,IntegerVal 0,IntegerVal 32767,IntegerVal (-1)],IndexVal 0], start_saturated = False}";
      int reported = 0;
      int16_t got;
      int16_t exp;
      arg1 = -32768;
      arg2 = vcombine_s16(vcreate_s16(UINT64_C(0xffff89e1ffff67ef)),
                          vcreate_s16(UINT64_C(0xffff7fff00007666)));
      clear_neon_saturated();
      //  Expect: "result" = 9811
      result = vqrdmulhh_laneq_s16(arg1, arg2, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = -26607;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIi16 " Got: %" PRIi16 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2380() {

{
   {
      int32_t arg1;
      int32x2_t arg2;
      int32_t result;
      char* str1 = "ReproInfo2 {semantics = \"qrdmlh_lane\", fnname = \"vqrdmulhs_lane_s32\", rettype = \"int32_t\", argtypes = \"[int32_t,int32x2_t,__constrange(0,1) int]\", vals = [IntegerVal (-65536),VectorVal [IntegerVal 312573951,IntegerVal (-375291904)],IndexVal 0], start_saturated = True}";
      int reported = 0;
      int32_t got;
      int32_t exp;
      arg1 = -65536;
      arg2 = vcreate_s32(UINT64_C(0xe9a1800012a17fff));
      set_neon_saturated();
      //  Expect: "result" = ffffdabd
      result = vqrdmulhs_lane_s32(arg1, arg2, 0);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      got = result;
      exp = -9539;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIi32 " Got: %" PRIi32 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2381() {

{
   {
      int32_t arg1;
      int32x4_t arg2;
      int32_t result;
      char* str1 = "ReproInfo2 {semantics = \"qrdmlh_lane\", fnname = \"vqrdmulhs_laneq_s32\", rettype = \"int32_t\", argtypes = \"[int32_t,int32x4_t,__constrange(0,3) int]\", vals = [IntegerVal 0,VectorVal [IntegerVal 2147450879,IntegerVal (-2078212096),IntegerVal (-32769),IntegerVal (-2147450881)],IndexVal 2], start_saturated = False}";
      int reported = 0;
      int32_t got;
      int32_t exp;
      arg1 = 0;
      arg2 = vcombine_s32(vcreate_s32(UINT64_C(0x842100007fff7fff)),
                          vcreate_s32(UINT64_C(0x80007fffffff7fff)));
      clear_neon_saturated();
      //  Expect: "result" = 00000000
      result = vqrdmulhs_laneq_s32(arg1, arg2, 2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = 0;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIi32 " Got: %" PRIi32 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2382() {

{
   {
      int16x4_t arg1;
      int16x4_t arg2;
      int16x4_t arg3;
      int16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"mla_lane\", fnname = \"vmla_lane_s16\", rettype = \"int16x4_t\", argtypes = \"[int16x4_t,int16x4_t,int16x4_t,__constrange(0,3) int]\", vals = [VectorVal [IntegerVal 17866,IntegerVal 31706,IntegerVal (-32768),IntegerVal (-1)],VectorVal [IntegerVal (-32768),IntegerVal 32767,IntegerVal (-1),IntegerVal (-1)],VectorVal [IntegerVal 0,IntegerVal 32767,IntegerVal 32767,IntegerVal (-32768)],IndexVal 3], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s16(UINT64_C(0xffff80007bda45ca));
      arg2 = vcreate_s16(UINT64_C(0xffffffff7fff8000));
      arg3 = vcreate_s16(UINT64_C(0x80007fff7fff0000));
      clear_neon_saturated();
      //  Expect: "result" = 7fff0000fbda45ca
      result = vmla_lane_s16(arg1, arg2, arg3, 3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s16(result), 0);
      exp = UINT64_C(0x7fff0000fbda45ca);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2383() {

{
   {
      int16x4_t arg1;
      int16x4_t arg2;
      int16x8_t arg3;
      int16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"mla_lane\", fnname = \"vmla_laneq_s16\", rettype = \"int16x4_t\", argtypes = \"[int16x4_t,int16x4_t,int16x8_t,__constrange(0,7) int]\", vals = [VectorVal [IntegerVal 0,IntegerVal (-32768),IntegerVal 0,IntegerVal (-32768)],VectorVal [IntegerVal (-32768),IntegerVal (-32768),IntegerVal (-12373),IntegerVal 0],VectorVal [IntegerVal 19501,IntegerVal (-1),IntegerVal (-32768),IntegerVal (-30239),IntegerVal (-32768),IntegerVal 0,IntegerVal (-32768),IntegerVal (-32768)],IndexVal 6], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s16(UINT64_C(0x8000000080000000));
      arg2 = vcreate_s16(UINT64_C(0x0000cfab80008000));
      arg3 = vcombine_s16(vcreate_s16(UINT64_C(0x89e18000ffff4c2d)),
                          vcreate_s16(UINT64_C(0x8000800000008000)));
      clear_neon_saturated();
      //  Expect: "result" = 8000800080000000
      result = vmla_laneq_s16(arg1, arg2, arg3, 6);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s16(result), 0);
      exp = UINT64_C(0x8000800080000000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2384() {

{
   {
      int32x2_t arg1;
      int32x2_t arg2;
      int32x2_t arg3;
      int32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"mla_lane\", fnname = \"vmla_lane_s32\", rettype = \"int32x2_t\", argtypes = \"[int32x2_t,int32x2_t,int32x2_t,__constrange(0,1) int]\", vals = [VectorVal [IntegerVal (-2147483648),IntegerVal (-148)],VectorVal [IntegerVal (-2147450880),IntegerVal (-2147483648)],VectorVal [IntegerVal (-2147418113),IntegerVal (-246415360)],IndexVal 0], start_saturated = True}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s32(UINT64_C(0xffffff6c80000000));
      arg2 = vcreate_s32(UINT64_C(0x8000000080008000));
      arg3 = vcreate_s32(UINT64_C(0xf15000008000ffff));
      set_neon_saturated();
      //  Expect: "result" = 7fffff6c7fff8000
      result = vmla_lane_s32(arg1, arg2, arg3, 0);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s32(result), 0);
      exp = UINT64_C(0x7fffff6c7fff8000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2385() {

{
   {
      int32x2_t arg1;
      int32x2_t arg2;
      int32x4_t arg3;
      int32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"mla_lane\", fnname = \"vmla_laneq_s32\", rettype = \"int32x2_t\", argtypes = \"[int32x2_t,int32x2_t,int32x4_t,__constrange(0,3) int]\", vals = [VectorVal [IntegerVal (-1),IntegerVal 65535],VectorVal [IntegerVal (-65536),IntegerVal 2147418112],VectorVal [IntegerVal 65535,IntegerVal 65535,IntegerVal 2147450879,IntegerVal (-616726529)],IndexVal 0], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s32(UINT64_C(0x0000ffffffffffff));
      arg2 = vcreate_s32(UINT64_C(0x7fff0000ffff0000));
      arg3 = vcombine_s32(vcreate_s32(UINT64_C(0x0000ffff0000ffff)),
                          vcreate_s32(UINT64_C(0xdb3d7fff7fff7fff)));
      clear_neon_saturated();
      //  Expect: "result" = 8001ffff0000ffff
      result = vmla_laneq_s32(arg1, arg2, arg3, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s32(result), 0);
      exp = UINT64_C(0x8001ffff0000ffff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2386() {

{
   {
      uint16x4_t arg1;
      uint16x4_t arg2;
      uint16x4_t arg3;
      uint16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"mla_lane\", fnname = \"vmla_lane_u16\", rettype = \"uint16x4_t\", argtypes = \"[uint16x4_t,uint16x4_t,uint16x4_t,__constrange(0,3) int]\", vals = [VectorVal [IntegerVal 32767,IntegerVal 65535,IntegerVal 44382,IntegerVal 32767],VectorVal [IntegerVal 0,IntegerVal 54377,IntegerVal 0,IntegerVal 65535],VectorVal [IntegerVal 65535,IntegerVal 62858,IntegerVal 32767,IntegerVal 32768],IndexVal 0], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u16(UINT64_C(0x7fffad5effff7fff));
      arg2 = vcreate_u16(UINT64_C(0xffff0000d4690000));
      arg3 = vcreate_u16(UINT64_C(0x80007ffff58affff));
      clear_neon_saturated();
      //  Expect: "result" = 8000ad5e2b967fff
      result = vmla_lane_u16(arg1, arg2, arg3, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u16(result), 0);
      exp = UINT64_C(0x8000ad5e2b967fff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2387() {

{
   {
      uint16x4_t arg1;
      uint16x4_t arg2;
      uint16x8_t arg3;
      uint16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"mla_lane\", fnname = \"vmla_laneq_u16\", rettype = \"uint16x4_t\", argtypes = \"[uint16x4_t,uint16x4_t,uint16x8_t,__constrange(0,7) int]\", vals = [VectorVal [IntegerVal 24894,IntegerVal 65535,IntegerVal 32768,IntegerVal 32767],VectorVal [IntegerVal 65535,IntegerVal 9707,IntegerVal 32978,IntegerVal 32768],VectorVal [IntegerVal 43929,IntegerVal 32767,IntegerVal 65535,IntegerVal 32767,IntegerVal 32767,IntegerVal 0,IntegerVal 65535,IntegerVal 32768],IndexVal 3], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u16(UINT64_C(0x7fff8000ffff613e));
      arg2 = vcreate_u16(UINT64_C(0x800080d225ebffff));
      arg3 = vcombine_u16(vcreate_u16(UINT64_C(0x7fffffff7fffab99)),
                          vcreate_u16(UINT64_C(0x8000ffff00007fff)));
      clear_neon_saturated();
      //  Expect: "result" = ffffff2e5a14e13f
      result = vmla_laneq_u16(arg1, arg2, arg3, 3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u16(result), 0);
      exp = UINT64_C(0xffffff2e5a14e13f);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2388() {

{
   {
      uint32x2_t arg1;
      uint32x2_t arg2;
      uint32x2_t arg3;
      uint32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"mla_lane\", fnname = \"vmla_lane_u32\", rettype = \"uint32x2_t\", argtypes = \"[uint32x2_t,uint32x2_t,uint32x2_t,__constrange(0,1) int]\", vals = [VectorVal [IntegerVal 32768,IntegerVal 4294967295],VectorVal [IntegerVal 2147450880,IntegerVal 2147516416],VectorVal [IntegerVal 2147504381,IntegerVal 4294934528],IndexVal 0], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u32(UINT64_C(0xffffffff00008000));
      arg2 = vcreate_u32(UINT64_C(0x800080007fff8000));
      arg3 = vcreate_u32(UINT64_C(0xffff8000800050fd));
      clear_neon_saturated();
      //  Expect: "result" = a87e7fff57820000
      result = vmla_lane_u32(arg1, arg2, arg3, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u32(result), 0);
      exp = UINT64_C(0xa87e7fff57820000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2389() {

{
   {
      uint32x2_t arg1;
      uint32x2_t arg2;
      uint32x4_t arg3;
      uint32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"mla_lane\", fnname = \"vmla_laneq_u32\", rettype = \"uint32x2_t\", argtypes = \"[uint32x2_t,uint32x2_t,uint32x4_t,__constrange(0,3) int]\", vals = [VectorVal [IntegerVal 32767,IntegerVal 4294934528],VectorVal [IntegerVal 2147516415,IntegerVal 2147516416],VectorVal [IntegerVal 2147429256,IntegerVal 4294934527,IntegerVal 32767,IntegerVal 4294967295],IndexVal 3], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u32(UINT64_C(0xffff800000007fff));
      arg2 = vcreate_u32(UINT64_C(0x8000800080007fff));
      arg3 = vcombine_u32(vcreate_u32(UINT64_C(0xffff7fff7fff2b88)),
                          vcreate_u32(UINT64_C(0xffffffff00007fff)));
      clear_neon_saturated();
      //  Expect: "result" = 7fff000080000000
      result = vmla_laneq_u32(arg1, arg2, arg3, 3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u32(result), 0);
      exp = UINT64_C(0x7fff000080000000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2390() {

{
   {
      int16x8_t arg1;
      int16x8_t arg2;
      int16x4_t arg3;
      int16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"mla_lane\", fnname = \"vmlaq_lane_s16\", rettype = \"int16x8_t\", argtypes = \"[int16x8_t,int16x8_t,int16x4_t,__constrange(0,3) int]\", vals = [VectorVal [IntegerVal 0,IntegerVal (-32768),IntegerVal 0,IntegerVal 0,IntegerVal (-1),IntegerVal 32767,IntegerVal 0,IntegerVal (-1)],VectorVal [IntegerVal (-1),IntegerVal 0,IntegerVal (-5909),IntegerVal (-1),IntegerVal (-21954),IntegerVal (-32768),IntegerVal (-17040),IntegerVal (-24193)],VectorVal [IntegerVal (-32768),IntegerVal 32767,IntegerVal 32767,IntegerVal (-32768)],IndexVal 3], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s16(vcreate_s16(UINT64_C(0x0000000080000000)),
                          vcreate_s16(UINT64_C(0xffff00007fffffff)));
      arg2 = vcombine_s16(vcreate_s16(UINT64_C(0xffffe8eb0000ffff)),
                          vcreate_s16(UINT64_C(0xa17fbd708000aa3e)));
      arg3 = vcreate_s16(UINT64_C(0x80007fff7fff8000));
      clear_neon_saturated();
      //  Expect: "result" = 7fff00007fffffff8000800080008000
      result = vmlaq_lane_s16(arg1, arg2, arg3, 3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 0);
         exp = UINT64_C(0x8000800080008000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 1);
         exp = UINT64_C(0x7fff00007fffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2391() {

{
   {
      int16x8_t arg1;
      int16x8_t arg2;
      int16x8_t arg3;
      int16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"mla_lane\", fnname = \"vmlaq_laneq_s16\", rettype = \"int16x8_t\", argtypes = \"[int16x8_t,int16x8_t,int16x8_t,__constrange(0,7) int]\", vals = [VectorVal [IntegerVal (-25095),IntegerVal (-17455),IntegerVal 32767,IntegerVal 32767,IntegerVal (-24405),IntegerVal (-16447),IntegerVal (-8871),IntegerVal 847],VectorVal [IntegerVal 0,IntegerVal 20004,IntegerVal 32767,IntegerVal 32767,IntegerVal (-1),IntegerVal 32767,IntegerVal (-1),IntegerVal (-1)],VectorVal [IntegerVal 0,IntegerVal (-1),IntegerVal (-1),IntegerVal (-32768),IntegerVal 27309,IntegerVal 5503,IntegerVal (-9729),IntegerVal 0],IndexVal 3], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s16(vcreate_s16(UINT64_C(0x7fff7fffbbd19df9)),
                          vcreate_s16(UINT64_C(0x034fdd59bfc1a0ab)));
      arg2 = vcombine_s16(vcreate_s16(UINT64_C(0x7fff7fff4e240000)),
                          vcreate_s16(UINT64_C(0xffffffff7fffffff)));
      arg3 = vcombine_s16(vcreate_s16(UINT64_C(0x8000ffffffff0000)),
                          vcreate_s16(UINT64_C(0x0000d9ff157f6aad)));
      clear_neon_saturated();
      //  Expect: "result" = 834f5d593fc120abffffffffbbd19df9
      result = vmlaq_laneq_s16(arg1, arg2, arg3, 3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 0);
         exp = UINT64_C(0xffffffffbbd19df9);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 1);
         exp = UINT64_C(0x834f5d593fc120ab);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2392() {

{
   {
      int32x4_t arg1;
      int32x4_t arg2;
      int32x2_t arg3;
      int32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"mla_lane\", fnname = \"vmlaq_lane_s32\", rettype = \"int32x4_t\", argtypes = \"[int32x4_t,int32x4_t,int32x2_t,__constrange(0,1) int]\", vals = [VectorVal [IntegerVal 18158,IntegerVal 0,IntegerVal 2147450879,IntegerVal (-2147461287)],VectorVal [IntegerVal 1769177088,IntegerVal (-62349),IntegerVal 65535,IntegerVal (-942902095)],VectorVal [IntegerVal 1328054272,IntegerVal 2147450879],IndexVal 1], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s32(vcreate_s32(UINT64_C(0x00000000000046ee)),
                          vcreate_s32(UINT64_C(0x800057597fff7fff)));
      arg2 = vcombine_s32(vcreate_s32(UINT64_C(0xffff0c7369738000)),
                          vcreate_s32(UINT64_C(0xc7cc74b10000ffff)));
      arg3 = vcreate_s32(UINT64_C(0x7fff7fff4f288000));
      clear_neon_saturated();
      //  Expect: "result" = fddb62a87fff0000f9c7738dd68cc6ee
      result = vmlaq_lane_s32(arg1, arg2, arg3, 1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 0);
         exp = UINT64_C(0xf9c7738dd68cc6ee);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 1);
         exp = UINT64_C(0xfddb62a87fff0000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2393() {

{
   {
      int32x4_t arg1;
      int32x4_t arg2;
      int32x4_t arg3;
      int32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"mla_lane\", fnname = \"vmlaq_laneq_s32\", rettype = \"int32x4_t\", argtypes = \"[int32x4_t,int32x4_t,int32x4_t,__constrange(0,3) int]\", vals = [VectorVal [IntegerVal (-2147450881),IntegerVal (-2147418113),IntegerVal 62880,IntegerVal 32767],VectorVal [IntegerVal 222778743,IntegerVal 65535,IntegerVal 65535,IntegerVal 32768],VectorVal [IntegerVal 2147450880,IntegerVal 2147450880,IntegerVal 2147472608,IntegerVal (-32769)],IndexVal 1], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s32(vcreate_s32(UINT64_C(0x8000ffff80007fff)),
                          vcreate_s32(UINT64_C(0x00007fff0000f5a0)));
      arg2 = vcombine_s32(vcreate_s32(UINT64_C(0x0000ffff0d475577)),
                          vcreate_s32(UINT64_C(0x000080000000ffff)));
      arg3 = vcombine_s32(vcreate_s32(UINT64_C(0x7fff80007fff8000)),
                          vcreate_s32(UINT64_C(0xffff7fff7fffd4e0)));
      clear_neon_saturated();
      //  Expect: "result" = c0007fff000175a080017fff5544ffff
      result = vmlaq_laneq_s32(arg1, arg2, arg3, 1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 0);
         exp = UINT64_C(0x80017fff5544ffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 1);
         exp = UINT64_C(0xc0007fff000175a0);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2394() {

{
   {
      uint16x8_t arg1;
      uint16x8_t arg2;
      uint16x4_t arg3;
      uint16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"mla_lane\", fnname = \"vmlaq_lane_u16\", rettype = \"uint16x8_t\", argtypes = \"[uint16x8_t,uint16x8_t,uint16x4_t,__constrange(0,3) int]\", vals = [VectorVal [IntegerVal 32768,IntegerVal 6010,IntegerVal 32767,IntegerVal 32768,IntegerVal 32768,IntegerVal 31308,IntegerVal 34661,IntegerVal 0],VectorVal [IntegerVal 32768,IntegerVal 0,IntegerVal 32767,IntegerVal 60787,IntegerVal 0,IntegerVal 32768,IntegerVal 32768,IntegerVal 49872],VectorVal [IntegerVal 32768,IntegerVal 32767,IntegerVal 32767,IntegerVal 32768],IndexVal 3], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u16(vcreate_u16(UINT64_C(0x80007fff177a8000)),
                          vcreate_u16(UINT64_C(0x000087657a4c8000)));
      arg2 = vcombine_u16(vcreate_u16(UINT64_C(0xed737fff00008000)),
                          vcreate_u16(UINT64_C(0xc2d0800080000000)));
      arg3 = vcreate_u16(UINT64_C(0x80007fff7fff8000));
      clear_neon_saturated();
      //  Expect: "result" = 000087657a4c80000000ffff177a8000
      result = vmlaq_lane_u16(arg1, arg2, arg3, 3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 0);
         exp = UINT64_C(0x0000ffff177a8000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 1);
         exp = UINT64_C(0x000087657a4c8000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2395() {

{
   {
      uint16x8_t arg1;
      uint16x8_t arg2;
      uint16x8_t arg3;
      uint16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"mla_lane\", fnname = \"vmlaq_laneq_u16\", rettype = \"uint16x8_t\", argtypes = \"[uint16x8_t,uint16x8_t,uint16x8_t,__constrange(0,7) int]\", vals = [VectorVal [IntegerVal 32767,IntegerVal 65535,IntegerVal 44440,IntegerVal 32767,IntegerVal 48136,IntegerVal 32767,IntegerVal 65535,IntegerVal 65535],VectorVal [IntegerVal 0,IntegerVal 60343,IntegerVal 32767,IntegerVal 32767,IntegerVal 0,IntegerVal 133,IntegerVal 0,IntegerVal 32767],VectorVal [IntegerVal 32767,IntegerVal 32767,IntegerVal 40948,IntegerVal 16326,IntegerVal 32767,IntegerVal 32768,IntegerVal 32768,IntegerVal 1034],IndexVal 4], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u16(vcreate_u16(UINT64_C(0x7fffad98ffff7fff)),
                          vcreate_u16(UINT64_C(0xffffffff7fffbc08)));
      arg2 = vcombine_u16(vcreate_u16(UINT64_C(0x7fff7fffebb70000)),
                          vcreate_u16(UINT64_C(0x7fff000000850000)));
      arg3 = vcombine_u16(vcreate_u16(UINT64_C(0x3fc69ff47fff7fff)),
                          vcreate_u16(UINT64_C(0x040a800080007fff)));
      clear_neon_saturated();
      //  Expect: "result" = 0000ffffff7abc088000ad9994487fff
      result = vmlaq_laneq_u16(arg1, arg2, arg3, 4);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 0);
         exp = UINT64_C(0x8000ad9994487fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 1);
         exp = UINT64_C(0x0000ffffff7abc08);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2396() {

{
   {
      uint32x4_t arg1;
      uint32x4_t arg2;
      uint32x2_t arg3;
      uint32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"mla_lane\", fnname = \"vmlaq_lane_u32\", rettype = \"uint32x4_t\", argtypes = \"[uint32x4_t,uint32x4_t,uint32x2_t,__constrange(0,1) int]\", vals = [VectorVal [IntegerVal 4294901760,IntegerVal 4294901760,IntegerVal 0,IntegerVal 4294901760],VectorVal [IntegerVal 2147476370,IntegerVal 4294901760,IntegerVal 0,IntegerVal 2147516416],VectorVal [IntegerVal 4294934528,IntegerVal 4294901760],IndexVal 0], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u32(vcreate_u32(UINT64_C(0xffff0000ffff0000)),
                          vcreate_u32(UINT64_C(0xffff000000000000)));
      arg2 = vcombine_u32(vcreate_u32(UINT64_C(0xffff00007fffe392)),
                          vcreate_u32(UINT64_C(0x8000800000000000)));
      arg3 = vcreate_u32(UINT64_C(0xffff0000ffff8000));
      clear_neon_saturated();
      //  Expect: "result" = bfff0000000000007fff00000e360000
      result = vmlaq_lane_u32(arg1, arg2, arg3, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 0);
         exp = UINT64_C(0x7fff00000e360000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 1);
         exp = UINT64_C(0xbfff000000000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2397() {

{
   {
      uint32x4_t arg1;
      uint32x4_t arg2;
      uint32x4_t arg3;
      uint32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"mla_lane\", fnname = \"vmlaq_laneq_u32\", rettype = \"uint32x4_t\", argtypes = \"[uint32x4_t,uint32x4_t,uint32x4_t,__constrange(0,3) int]\", vals = [VectorVal [IntegerVal 2147483647,IntegerVal 4294934527,IntegerVal 279576575,IntegerVal 1680317261],VectorVal [IntegerVal 2147483647,IntegerVal 2147513505,IntegerVal 0,IntegerVal 4190076928],VectorVal [IntegerVal 0,IntegerVal 2721775616,IntegerVal 384729088,IntegerVal 2285830144],IndexVal 3], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u32(vcreate_u32(UINT64_C(0xffff7fff7fffffff)),
                          vcreate_u32(UINT64_C(0x64279b4d10a9ffff)));
      arg2 = vcombine_u32(vcreate_u32(UINT64_C(0x800074a17fffffff)),
                          vcreate_u32(UINT64_C(0xf9bf800000000000)));
      arg3 = vcombine_u32(vcreate_u32(UINT64_C(0xa23b000000000000)),
                          vcreate_u32(UINT64_C(0x883f000016ee8000)));
      clear_neon_saturated();
      //  Expect: "result" = e4279b4d10a9ffff3b9e7ffff7c0ffff
      result = vmlaq_laneq_u32(arg1, arg2, arg3, 3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 0);
         exp = UINT64_C(0x3b9e7ffff7c0ffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 1);
         exp = UINT64_C(0xe4279b4d10a9ffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2398() {

{
   {
      float32x2_t arg1;
      float32x2_t arg2;
      float32x2_t arg3;
      float32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"mla_lane\", fnname = \"vfma_lane_f32\", rettype = \"float32x2_t\", argtypes = \"[float32x2_t,float32x2_t,float32x2_t,__constrange(0,1) int]\", vals = [VectorVal [FloatVal 0.9525248408317566,FloatVal 0.7446416616439819],VectorVal [FloatVal 0.9034276604652405,FloatVal 0.7931913137435913],VectorVal [FloatVal 0.7016945481300354,FloatVal 0.4259512424468994],IndexVal 0], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_f32(UINT64_C(0x3f3ea0d63f73d8ab));
      arg2 = vcreate_f32(UINT64_C(0x3f4b0e963f674709));
      arg3 = vcreate_f32(UINT64_C(0x3eda16483f33a241));
      clear_neon_saturated();
      //  Expect: "result" = 3fa68e5e3fcb10f6
      result = vfma_lane_f32(arg1, arg2, arg3, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result, 0);
         exp = ((float32_t) 1.5864551067352295);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result, 1);
         exp = ((float32_t) 1.3012197017669678);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
   }
}
}
void dotests_2399() {

{
   {
      float32x2_t arg1;
      float32x2_t arg2;
      float32x4_t arg3;
      float32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"mla_lane\", fnname = \"vfma_laneq_f32\", rettype = \"float32x2_t\", argtypes = \"[float32x2_t,float32x2_t,float32x4_t,__constrange(0,3) int]\", vals = [VectorVal [FloatVal 0.8711131811141968,FloatVal 0.1715407371520996],VectorVal [FloatVal 6.279289722442627e-3,FloatVal 0.5345693826675415],VectorVal [FloatVal 0.7372342944145203,FloatVal 0.7231391668319702,FloatVal 0.6362443566322327,FloatVal 0.43235015869140625],IndexVal 0], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_f32(UINT64_C(0x3e2fa8603f5f0146));
      arg2 = vcreate_f32(UINT64_C(0x3f08d98a3bcdc280));
      arg3 = vcombine_f32(vcreate_f32(UINT64_C(0x3f391fa63f3cbb63)),
                          vcreate_f32(UINT64_C(0x3edd5d003f22e0e9)));
      clear_neon_saturated();
      //  Expect: "result" = 3f10ce053f6030a9
      result = vfma_laneq_f32(arg1, arg2, arg3, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result, 0);
         exp = ((float32_t) 0.875742495059967);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result, 1);
         exp = ((float32_t) 0.5656436085700989);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
   }
}
}
void dotests_2400() {

{
   {
      float64x1_t arg1;
      float64x1_t arg2;
      float64x1_t arg3;
      float64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"mla_lane\", fnname = \"vfma_lane_f64\", rettype = \"float64x1_t\", argtypes = \"[float64x1_t,float64x1_t,float64x1_t,__constrange(0,0) int]\", vals = [VectorVal [FloatVal 0.45128993777208126],VectorVal [FloatVal 0.6120605458965698],VectorVal [FloatVal 0.9453403685538394],IndexVal 0], start_saturated = False}";
      int reported = 0;
      float64_t got;
      float64_t exp;
      arg1 = vcreate_f64(UINT64_C(0x3fdce1ef30efad7e));
      arg2 = vcreate_f64(UINT64_C(0x3fe395ffff79868c));
      arg3 = vcreate_f64(UINT64_C(0x3fee403a71d0dfdd));
      clear_neon_saturated();
      //  Expect: "result" = 3ff07a73aec11f7f
      result = vfma_lane_f64(arg1, arg2, arg3, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_f64(result, 0);
      exp = 1.0298954798072086;
      if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
         }
   }
}
}
void dotests_2401() {

{
   {
      float64x1_t arg1;
      float64x1_t arg2;
      float64x2_t arg3;
      float64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"mla_lane\", fnname = \"vfma_laneq_f64\", rettype = \"float64x1_t\", argtypes = \"[float64x1_t,float64x1_t,float64x2_t,__constrange(0,1) int]\", vals = [VectorVal [FloatVal 0.284816444325261],VectorVal [FloatVal 0.2197347582721304],VectorVal [FloatVal 9.518734521169192e-2,FloatVal 0.8407577038573214],IndexVal 1], start_saturated = False}";
      int reported = 0;
      float64_t got;
      float64_t exp;
      arg1 = vcreate_f64(UINT64_C(0x3fd23a6ec06f5c2c));
      arg2 = vcreate_f64(UINT64_C(0x3fcc2044c04960c4));
      arg3 = vcombine_f64(vcreate_f64(UINT64_C(0x3fb85e32a6ad6228)),
                          vcreate_f64(UINT64_C(0x3feae77cb33dac05)));
      clear_neon_saturated();
      //  Expect: "result" = 3fde0d45f3fdc388
      result = vfma_laneq_f64(arg1, arg2, arg3, 1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_f64(result, 0);
      exp = 0.46956013514778094;
      if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
         }
   }
}
}
void dotests_2402() {

{
   {
      float32x4_t arg1;
      float32x4_t arg2;
      float32x2_t arg3;
      float32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"mla_lane\", fnname = \"vfmaq_lane_f32\", rettype = \"float32x4_t\", argtypes = \"[float32x4_t,float32x4_t,float32x2_t,__constrange(0,1) int]\", vals = [VectorVal [FloatVal 0.7766698598861694,FloatVal 0.20754480361938477,FloatVal 0.2455121874809265,FloatVal 0.24655824899673462],VectorVal [FloatVal 0.20629554986953735,FloatVal 2.65500545501709e-2,FloatVal 0.8716757893562317,FloatVal 0.40992963314056396],VectorVal [FloatVal 0.4543294310569763,FloatVal 0.822100043296814],IndexVal 0], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_f32(vcreate_f32(UINT64_C(0x3e5486a03f46d3d6)),
                          vcreate_f32(UINT64_C(0x3e7c79c43e7b678c)));
      arg2 = vcombine_f32(vcreate_f32(UINT64_C(0x3cd97f803e533f24)),
                          vcreate_f32(UINT64_C(0x3ed1e24c3f5f2625)));
      arg3 = vcreate_f32(UINT64_C(0x3f5275263ee89dde));
      clear_neon_saturated();
      //  Expect: "result" = 3edd98233f243bfa3e60e0bb3f5ed246
      result = vfmaq_lane_f32(arg1, arg2, arg3, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 0);
         exp = ((float32_t) 0.8703960180282593);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 1);
         exp = ((float32_t) 0.21960727870464325);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 2);
         exp = ((float32_t) 0.6415401697158813);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 2 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 3);
         exp = ((float32_t) 0.43280133605003357);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 3 ", exp, got);
            }
      }
   }
}
}
void dotests_2403() {

{
   {
      float32x4_t arg1;
      float32x4_t arg2;
      float32x4_t arg3;
      float32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"mla_lane\", fnname = \"vfmaq_laneq_f32\", rettype = \"float32x4_t\", argtypes = \"[float32x4_t,float32x4_t,float32x4_t,__constrange(0,3) int]\", vals = [VectorVal [FloatVal 0.8471323251724243,FloatVal 0.8758784532546997,FloatVal 0.6627621054649353,FloatVal 0.6107392311096191],VectorVal [FloatVal 0.914262592792511,FloatVal 0.835869550704956,FloatVal 0.6385859251022339,FloatVal 0.9340704679489136],VectorVal [FloatVal 0.9660077691078186,FloatVal 0.7683060765266418,FloatVal 0.40159618854522705,FloatVal 0.3733660578727722],IndexVal 3], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_f32(vcreate_f32(UINT64_C(0x3f6039923f58ddaa)),
                          vcreate_f32(UINT64_C(0x3f1c59683f29aac7)));
      arg2 = vcombine_f32(vcreate_f32(UINT64_C(0x3f55fb8c3f6a0d1d)),
                          vcreate_f32(UINT64_C(0x3f6f1f3e3f237a5e)));
      arg3 = vcombine_f32(vcreate_f32(UINT64_C(0x3f44afb53f774c49)),
                          vcreate_f32(UINT64_C(0x3ebf29d63ecd9e04)));
      clear_neon_saturated();
      //  Expect: "result" = 3f75a11a3f66b4493f980f323f982057
      result = vfmaq_laneq_f32(arg1, arg2, arg3, 3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 0);
         exp = ((float32_t) 1.188486933708191);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 1);
         exp = ((float32_t) 1.1879637241363525);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 2);
         exp = ((float32_t) 0.9011884331703186);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 2 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 3);
         exp = ((float32_t) 0.9594894647598267);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 3 ", exp, got);
            }
      }
   }
}
}
void dotests_2404() {

{
   {
      float64x2_t arg1;
      float64x2_t arg2;
      float64x1_t arg3;
      float64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"mla_lane\", fnname = \"vfmaq_lane_f64\", rettype = \"float64x2_t\", argtypes = \"[float64x2_t,float64x2_t,float64x1_t,__constrange(0,0) int]\", vals = [VectorVal [FloatVal 0.23260724083853723,FloatVal 0.6994509575350557],VectorVal [FloatVal 0.49439148196668226,FloatVal 0.7184938331888965],VectorVal [FloatVal 7.391506196955566e-2],IndexVal 0], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_f64(vcreate_f64(UINT64_C(0x3fcdc612f61b6e9c)),
                          vcreate_f64(UINT64_C(0x3fe661e6f9789b3b)));
      arg2 = vcombine_f64(vcreate_f64(UINT64_C(0x3fdfa41c2b9df1a6)),
                          vcreate_f64(UINT64_C(0x3fe6fde6c77d9153)));
      arg3 = vcreate_f64(UINT64_C(0x3fb2ec18f5d74f60));
      clear_neon_saturated();
      //  Expect: "result" = 3fe814f582214e233fd139c1d5dc5796
      result = vfmaq_lane_f64(arg1, arg2, arg3, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float64_t got;
         float64_t exp;
         got = vgetq_lane_f64(result, 0);
         exp = 0.269150217865325;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float64_t got;
         float64_t exp;
         got = vgetq_lane_f64(result, 1);
         exp = 0.7525584737399565;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
   }
}
}
void dotests_2405() {

{
   {
      float64x2_t arg1;
      float64x2_t arg2;
      float64x2_t arg3;
      float64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"mla_lane\", fnname = \"vfmaq_laneq_f64\", rettype = \"float64x2_t\", argtypes = \"[float64x2_t,float64x2_t,float64x2_t,__constrange(0,1) int]\", vals = [VectorVal [FloatVal 0.9900878068497697,FloatVal 0.32181732155672016],VectorVal [FloatVal 0.5793209512113352,FloatVal 0.18919541250099603],VectorVal [FloatVal 0.9061734119987057,FloatVal 0.5114645698160271],IndexVal 0], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_f64(vcreate_f64(UINT64_C(0x3fefaecc9fd2d1ed)),
                          vcreate_f64(UINT64_C(0x3fd498a7add7d5e0)));
      arg2 = vcombine_f64(vcreate_f64(UINT64_C(0x3fe289cc176ae3b5)),
                          vcreate_f64(UINT64_C(0x3fc8378e269f5c68)));
      arg3 = vcombine_f64(vcreate_f64(UINT64_C(0x3fecff5f622140ec)),
                          vcreate_f64(UINT64_C(0x3fe05deaf20d857d)));
      clear_neon_saturated();
      //  Expect: "result" = 3fdf919750b819783ff83da8444d0f9b
      result = vfmaq_laneq_f64(arg1, arg2, arg3, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float64_t got;
         float64_t exp;
         got = vgetq_lane_f64(result, 0);
         exp = 1.515053049851281;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float64_t got;
         float64_t exp;
         got = vgetq_lane_f64(result, 1);
         exp = 0.49326117403725034;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
   }
}
}
void dotests_2406() {

{
   {
      float32_t arg1;
      float32_t arg2;
      float32x2_t arg3;
      float32_t result;
      char* str1 = "ReproInfo2 {semantics = \"mla_lane\", fnname = \"vfmas_lane_f32\", rettype = \"float32_t\", argtypes = \"[float32_t,float32_t,float32x2_t,__constrange(0,1) int]\", vals = [FloatVal 6.944805383682251e-2,FloatVal 0.6654084920883179,VectorVal [FloatVal 3.431713581085205e-2,FloatVal 0.9766836166381836],IndexVal 0], start_saturated = False}";
      int reported = 0;
      float32_t got;
      float32_t exp;
      arg1 = ((float32_t) 6.944805383682251e-2);
      arg2 = ((float32_t) 0.6654084920883179);
      arg3 = vcreate_f32(UINT64_C(0x3f7a07f03d0c9020));
      clear_neon_saturated();
      //  Expect: "result" = 3dbcfeda
      result = vfmas_lane_f32(arg1, arg2, arg3, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = ((float32_t) 9.22829657793045e-2);
      if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %f Got: %f\n", "   ", exp, got);
         }
   }
}
}
void dotests_2407() {

{
   {
      float32_t arg1;
      float32_t arg2;
      float32x4_t arg3;
      float32_t result;
      char* str1 = "ReproInfo2 {semantics = \"mla_lane\", fnname = \"vfmas_laneq_f32\", rettype = \"float32_t\", argtypes = \"[float32_t,float32_t,float32x4_t,__constrange(0,3) int]\", vals = [FloatVal 0.6648470163345337,FloatVal 0.925866425037384,VectorVal [FloatVal 0.7897496819496155,FloatVal 0.41474485397338867,FloatVal 0.7151882648468018,FloatVal 0.9075801372528076],IndexVal 3], start_saturated = False}";
      int reported = 0;
      float32_t got;
      float32_t exp;
      arg1 = ((float32_t) 0.6648470163345337);
      arg2 = ((float32_t) 0.925866425037384);
      arg3 = vcombine_f32(vcreate_f32(UINT64_C(0x3ed459703f4a2d09)),
                          vcreate_f32(UINT64_C(0x3f68572c3f371694)));
      clear_neon_saturated();
      //  Expect: "result" = 3fc0a897
      result = vfmas_laneq_f32(arg1, arg2, arg3, 3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = ((float32_t) 1.5051449537277222);
      if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %f Got: %f\n", "   ", exp, got);
         }
   }
}
}
void dotests_2408() {

{
   {
      float64_t arg1;
      float64_t arg2;
      float64x1_t arg3;
      float64_t result;
      char* str1 = "ReproInfo2 {semantics = \"mla_lane\", fnname = \"vfmad_lane_f64\", rettype = \"float64_t\", argtypes = \"[float64_t,float64_t,float64x1_t,__constrange(0,0) int]\", vals = [FloatVal 0.4169615421446565,FloatVal 0.19639008762201327,VectorVal [FloatVal 0.5596527283583369],IndexVal 0], start_saturated = False}";
      int reported = 0;
      float64_t got;
      float64_t exp;
      arg1 = 0.4169615421446565;
      arg2 = 0.19639008762201327;
      arg3 = vcreate_f64(UINT64_C(0x3fe1e8acd6ad51bf));
      clear_neon_saturated();
      //  Expect: "result" = 3fe0dc223aace7c1
      result = vfmad_lane_f64(arg1, arg2, arg3, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = 0.5268717905048491;
      if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %f Got: %f\n", "   ", exp, got);
         }
   }
}
}
void dotests_2409() {

{
   {
      float64_t arg1;
      float64_t arg2;
      float64x2_t arg3;
      float64_t result;
      char* str1 = "ReproInfo2 {semantics = \"mla_lane\", fnname = \"vfmad_laneq_f64\", rettype = \"float64_t\", argtypes = \"[float64_t,float64_t,float64x2_t,__constrange(0,1) int]\", vals = [FloatVal 0.18801675742290358,FloatVal 0.34245808542306155,VectorVal [FloatVal 0.32540281164170515,FloatVal 0.8930157931538786],IndexVal 1], start_saturated = False}";
      int reported = 0;
      float64_t got;
      float64_t exp;
      arg1 = 0.18801675742290358;
      arg2 = 0.34245808542306155;
      arg3 = vcombine_f64(vcreate_f64(UINT64_C(0x3fd4d3665081c3bc)),
                          vcreate_f64(UINT64_C(0x3fec9395db4d097f)));
      clear_neon_saturated();
      //  Expect: "result" = 3fdf9b077ec15fac
      result = vfmad_laneq_f64(arg1, arg2, arg3, 1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = 0.4938372361989376;
      if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %f Got: %f\n", "   ", exp, got);
         }
   }
}
}
void dotests_2410() {

{
   {
      float32x2_t arg1;
      float32x2_t arg2;
      float32x2_t arg3;
      float32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"mla_lane\", fnname = \"vmla_lane_f32\", rettype = \"float32x2_t\", argtypes = \"[float32x2_t,float32x2_t,float32x2_t,__constrange(0,1) int]\", vals = [VectorVal [FloatVal 0.8163589239120483,FloatVal 0.7586740255355835],VectorVal [FloatVal 0.6786627173423767,FloatVal 0.9246636629104614],VectorVal [FloatVal 0.5838546752929688,FloatVal 0.15542900562286377],IndexVal 1], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_f32(UINT64_C(0x3f4238763f50fce6));
      arg2 = vcreate_f32(UINT64_C(0x3f6cb6c23f2dbcd7));
      arg3 = vcreate_f32(UINT64_C(0x3e1f28c83f157780));
      clear_neon_saturated();
      //  Expect: "result" = 3f6703443f6bfde4
      result = vmla_lane_f32(arg1, arg2, arg3, 1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result, 0);
         exp = ((float32_t) 0.9218428134918213);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result, 1);
         exp = ((float32_t) 0.9023935794830322);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
   }
}
}
void dotests_2411() {

{
   {
      float32x2_t arg1;
      float32x2_t arg2;
      float32x4_t arg3;
      float32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"mla_lane\", fnname = \"vmla_laneq_f32\", rettype = \"float32x2_t\", argtypes = \"[float32x2_t,float32x2_t,float32x4_t,__constrange(0,3) int]\", vals = [VectorVal [FloatVal 6.523311138153076e-2,FloatVal 0.20075112581253052],VectorVal [FloatVal 0.7963606119155884,FloatVal 2.095574140548706e-2],VectorVal [FloatVal 2.684962749481201e-2,FloatVal 0.8889540433883667,FloatVal 0.9037476181983948,FloatVal 0.9084766507148743],IndexVal 3], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_f32(UINT64_C(0x3e4d91b43d8598f0));
      arg2 = vcreate_f32(UINT64_C(0x3cabab603f4bde4a));
      arg3 = vcombine_f32(vcreate_f32(UINT64_C(0x3f63927e3cdbf3c0)),
                          vcreate_f32(UINT64_C(0x3f6891ed3f675c01)));
      clear_neon_saturated();
      //  Expect: "result" = 3e6110593f49e8c7
      result = vmla_laneq_f32(arg1, arg2, arg3, 3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result, 0);
         exp = ((float32_t) 0.7887081503868103);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result, 1);
         exp = ((float32_t) 0.21978892385959625);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
   }
}
}
void dotests_2412() {

{
   {
      float32x4_t arg1;
      float32x4_t arg2;
      float32x2_t arg3;
      float32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"mla_lane\", fnname = \"vmlaq_lane_f32\", rettype = \"float32x4_t\", argtypes = \"[float32x4_t,float32x4_t,float32x2_t,__constrange(0,1) int]\", vals = [VectorVal [FloatVal 0.5300771594047546,FloatVal 0.6326512098312378,FloatVal 0.9896042943000793,FloatVal 0.27108216285705566],VectorVal [FloatVal 0.9907576441764832,FloatVal 9.965956211090088e-3,FloatVal 0.6733850240707397,FloatVal 0.8533217906951904],VectorVal [FloatVal 0.6736316680908203,FloatVal 0.18851780891418457],IndexVal 0], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_f32(vcreate_f32(UINT64_C(0x3f21f56e3f07b323)),
                          vcreate_f32(UINT64_C(0x3e8acb483f7d56b5)));
      arg2 = vcombine_f32(vcreate_f32(UINT64_C(0x3c2348403f7da24b)),
                          vcreate_f32(UINT64_C(0x3f5a734c3f2c62f6)));
      arg3 = vcreate_f32(UINT64_C(0x3e410ad03f2c7320));
      clear_neon_saturated();
      //  Expect: "result" = 3f588d583fb8bb5c3f23ad663f99471e
      result = vmlaq_lane_f32(arg1, arg2, arg3, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 0);
         exp = ((float32_t) 1.1974828243255615);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 1);
         exp = ((float32_t) 0.6393646001815796);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 2);
         exp = ((float32_t) 1.4432177543640137);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 2 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 3);
         exp = ((float32_t) 0.8459067344665527);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 3 ", exp, got);
            }
      }
   }
}
}
void dotests_2413() {

{
   {
      float32x4_t arg1;
      float32x4_t arg2;
      float32x4_t arg3;
      float32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"mla_lane\", fnname = \"vmlaq_laneq_f32\", rettype = \"float32x4_t\", argtypes = \"[float32x4_t,float32x4_t,float32x4_t,__constrange(0,3) int]\", vals = [VectorVal [FloatVal 0.8707767128944397,FloatVal 0.16866189241409302,FloatVal 0.2640937566757202,FloatVal 0.9068331122398376],VectorVal [FloatVal 0.7495366334915161,FloatVal 0.13808304071426392,FloatVal 0.7142588496208191,FloatVal 0.3257002830505371],VectorVal [FloatVal 0.16539305448532104,FloatVal 0.6992125511169434,FloatVal 0.38579970598220825,FloatVal 0.201788067817688],IndexVal 3], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_f32(vcreate_f32(UINT64_C(0x3e2cb5b43f5eeb39)),
                          vcreate_f32(UINT64_C(0x3f6826373e87374c)));
      arg2 = vcombine_f32(vcreate_f32(UINT64_C(0x3e0d65a43f3fe1a2)),
                          vcreate_f32(UINT64_C(0x3ea6c2303f36d9ab)));
      arg3 = vcombine_f32(vcreate_f32(UINT64_C(0x3f32ff983e295ccc)),
                          vcreate_f32(UINT64_C(0x3e4ea1883ec5878a)));
      clear_neon_saturated();
      //  Expect: "result" = 3f78f9663ed102903e493df53f82d1b1
      result = vmlaq_laneq_f32(arg1, arg2, arg3, 3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 0);
         exp = ((float32_t) 1.0220242738723755);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 1);
         exp = ((float32_t) 0.19652540981769562);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 2);
         exp = ((float32_t) 0.40822267532348633);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 2 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 3);
         exp = ((float32_t) 0.9725555181503296);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 3 ", exp, got);
            }
      }
   }
}
}
void dotests_2414() {

{
   {
      float32x2_t arg1;
      float32x2_t arg2;
      float32x2_t arg3;
      float32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"mls_lane\", fnname = \"vfms_lane_f32\", rettype = \"float32x2_t\", argtypes = \"[float32x2_t,float32x2_t,float32x2_t,__constrange(0,1) int]\", vals = [VectorVal [FloatVal 0.4989704489707947,FloatVal 2.712935209274292e-2],VectorVal [FloatVal 7.29759931564331e-2,FloatVal 4.540795087814331e-2],VectorVal [FloatVal 0.6975736618041992,FloatVal 0.24631458520889282],IndexVal 1], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_f32(UINT64_C(0x3cde3e603eff790e));
      arg2 = vcreate_f32(UINT64_C(0x3d39fdb03d957470));
      arg3 = vcreate_f32(UINT64_C(0x3e7c39e43f329430));
      clear_neon_saturated();
      //  Expect: "result" = 3c829e7c3ef64507
      result = vfms_lane_f32(arg1, arg2, arg3, 1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result, 0);
         exp = ((float32_t) 0.48099538683891296);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result, 1);
         exp = ((float32_t) 1.59447118639946e-2);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
   }
}
}
void dotests_2415() {

{
   {
      float32x2_t arg1;
      float32x2_t arg2;
      float32x4_t arg3;
      float32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"mls_lane\", fnname = \"vfms_laneq_f32\", rettype = \"float32x2_t\", argtypes = \"[float32x2_t,float32x2_t,float32x4_t,__constrange(0,3) int]\", vals = [VectorVal [FloatVal 0.20790785551071167,FloatVal 0.9966190457344055],VectorVal [FloatVal 0.18812143802642822,FloatVal 0.9852683544158936],VectorVal [FloatVal 0.12952029705047607,FloatVal 2.8076112270355225e-2,FloatVal 8.308011293411255e-2,FloatVal 0.11367523670196533],IndexVal 0], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_f32(UINT64_C(0x3f7f226d3e54e5cc));
      arg2 = vcreate_f32(UINT64_C(0x3f7c3a8c3e40a2e8));
      arg3 = vcombine_f32(vcreate_f32(UINT64_C(0x3ce5ffe03e04a0f8)),
                          vcreate_f32(UINT64_C(0x3de8ce903daa25e8)));
      clear_neon_saturated();
      //  Expect: "result" = 3f5e773b3e3bf284
      result = vfms_laneq_f32(arg1, arg2, arg3, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result, 0);
         exp = ((float32_t) 0.18354231119155884);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result, 1);
         exp = ((float32_t) 0.8690068125724792);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
   }
}
}
void dotests_2416() {

{
   {
      float64x1_t arg1;
      float64x1_t arg2;
      float64x1_t arg3;
      float64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"mls_lane\", fnname = \"vfms_lane_f64\", rettype = \"float64x1_t\", argtypes = \"[float64x1_t,float64x1_t,float64x1_t,__constrange(0,0) int]\", vals = [VectorVal [FloatVal 3.3051019705844786e-2],VectorVal [FloatVal 8.345688185956257e-2],VectorVal [FloatVal 0.42588119429612925],IndexVal 0], start_saturated = False}";
      int reported = 0;
      float64_t got;
      float64_t exp;
      arg1 = vcreate_f64(UINT64_C(0x3fa0ec103178dc30));
      arg2 = vcreate_f64(UINT64_C(0x3fb55d6e22368458));
      arg3 = vcreate_f64(UINT64_C(0x3fdb41a3325eee56));
      clear_neon_saturated();
      //  Expect: "result" = bf6469778a4fe260
      result = vfms_lane_f64(arg1, arg2, arg3, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_f64(result, 0);
      exp = -2.491696812736685e-3;
      if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
         }
   }
}
}
void dotests_2417() {

{
   {
      float64x1_t arg1;
      float64x1_t arg2;
      float64x2_t arg3;
      float64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"mls_lane\", fnname = \"vfms_laneq_f64\", rettype = \"float64x1_t\", argtypes = \"[float64x1_t,float64x1_t,float64x2_t,__constrange(0,1) int]\", vals = [VectorVal [FloatVal 0.5396316042475514],VectorVal [FloatVal 9.499957781471313e-2],VectorVal [FloatVal 0.725491937032843,FloatVal 7.773561986134003e-2],IndexVal 0], start_saturated = False}";
      int reported = 0;
      float64_t got;
      float64_t exp;
      arg1 = vcreate_f64(UINT64_C(0x3fe144a97f84332f));
      arg2 = vcreate_f64(UINT64_C(0x3fb851e46fd91688));
      arg3 = vcombine_f64(vcreate_f64(UINT64_C(0x3fe7373adde22b06)),
                          vcreate_f64(UINT64_C(0x3fb3e67b4909eb18)));
      clear_neon_saturated();
      //  Expect: "result" = 3fde201d9383752e
      result = vfms_laneq_f64(arg1, arg2, arg3, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_f64(result, 0);
      exp = 0.47071017652145286;
      if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
         }
   }
}
}
void dotests_2418() {

{
   {
      float32x4_t arg1;
      float32x4_t arg2;
      float32x2_t arg3;
      float32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"mls_lane\", fnname = \"vfmsq_lane_f32\", rettype = \"float32x4_t\", argtypes = \"[float32x4_t,float32x4_t,float32x2_t,__constrange(0,1) int]\", vals = [VectorVal [FloatVal 0.9639492630958557,FloatVal 0.5854794383049011,FloatVal 0.25238287448883057,FloatVal 0.9059271812438965],VectorVal [FloatVal 0.6361620426177979,FloatVal 0.37370240688323975,FloatVal 0.42245638370513916,FloatVal 0.17832708358764648],VectorVal [FloatVal 0.30625373125076294,FloatVal 0.5954182147979736],IndexVal 0], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_f32(vcreate_f32(UINT64_C(0x3f15e1fb3f76c561)),
                          vcreate_f32(UINT64_C(0x3f67ead83e813854)));
      arg2 = vcombine_f32(vcreate_f32(UINT64_C(0x3ebf55ec3f22db84)),
                          vcreate_f32(UINT64_C(0x3e369b603ed84c34)));
      arg3 = vcreate_f32(UINT64_C(0x3f186d543e9ccd4a));
      clear_neon_saturated();
      //  Expect: "result" = 3f59efb43dfbe98a3ef12b113f44e532
      result = vfmsq_lane_f32(arg1, arg2, arg3, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 0);
         exp = ((float32_t) 0.7691222429275513);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 1);
         exp = ((float32_t) 0.47103169560432434);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 2);
         exp = ((float32_t) 0.12300403416156769);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 2 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 3);
         exp = ((float32_t) 0.8513138294219971);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 3 ", exp, got);
            }
      }
   }
}
}
void dotests_2419() {

{
   {
      float32x4_t arg1;
      float32x4_t arg2;
      float32x4_t arg3;
      float32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"mls_lane\", fnname = \"vfmsq_laneq_f32\", rettype = \"float32x4_t\", argtypes = \"[float32x4_t,float32x4_t,float32x4_t,__constrange(0,3) int]\", vals = [VectorVal [FloatVal 0.8311358690261841,FloatVal 5.9058189392089844e-2,FloatVal 0.9635165929794312,FloatVal 0.22542989253997803],VectorVal [FloatVal 3.244030475616455e-2,FloatVal 0.5906568765640259,FloatVal 0.18560421466827393,FloatVal 0.3372519612312317],VectorVal [FloatVal 0.956049382686615,FloatVal 0.32538360357284546,FloatVal 0.9548104405403137,FloatVal 0.6423030495643616],IndexVal 2], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_f32(vcreate_f32(UINT64_C(0x3d71e7003f54c552)),
                          vcreate_f32(UINT64_C(0x3e66d7183f76a906)));
      arg2 = vcombine_f32(vcreate_f32(UINT64_C(0x3f17354a3d04e020)),
                          vcreate_f32(UINT64_C(0x3eacac4a3e3e0f08)));
      arg3 = vcombine_f32(vcreate_f32(UINT64_C(0x3ea698ae3f74bfa7)),
                          vcreate_f32(UINT64_C(0x3f246df93f746e75)));
      clear_neon_saturated();
      //  Expect: "result" = bdc5ccae3f494af1bf0141993f4cd763
      result = vfmsq_laneq_f32(arg1, arg2, arg3, 2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 0);
         exp = ((float32_t) 0.8001615405082703);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 1);
         exp = ((float32_t) -0.5049071907997131);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 2);
         exp = ((float32_t) 0.7862997651100159);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 2 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 3);
         exp = ((float32_t) -9.658180177211761e-2);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 3 ", exp, got);
            }
      }
   }
}
}
void dotests_2420() {

{
   {
      float64x2_t arg1;
      float64x2_t arg2;
      float64x1_t arg3;
      float64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"mls_lane\", fnname = \"vfmsq_lane_f64\", rettype = \"float64x2_t\", argtypes = \"[float64x2_t,float64x2_t,float64x1_t,__constrange(0,0) int]\", vals = [VectorVal [FloatVal 0.5569256780237118,FloatVal 0.9878688430672836],VectorVal [FloatVal 0.8792869886155367,FloatVal 0.9466594166179756],VectorVal [FloatVal 0.30649868672218805],IndexVal 0], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_f64(vcreate_f64(UINT64_C(0x3fe1d255ccad4353)),
                          vcreate_f64(UINT64_C(0x3fef9c9f1eb6c34b)));
      arg2 = vcombine_f64(vcreate_f64(UINT64_C(0x3fec231e777cdda1)),
                          vcreate_f64(UINT64_C(0x3fee4b08b05a637c)));
      arg3 = vcreate_f64(UINT64_C(0x3fd39dacaaef47a2));
      clear_neon_saturated();
      //  Expect: "result" = 3fe653b6be7b64e23fd2652d61dd6d0d
      result = vfmsq_lane_f64(arg1, arg2, arg3, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float64_t got;
         float64_t exp;
         got = vgetq_lane_f64(result, 0);
         exp = 0.28742537076114233;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float64_t got;
         float64_t exp;
         got = vgetq_lane_f64(result, 1);
         exp = 0.6977189751006814;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
   }
}
}
void dotests_2421() {

{
   {
      float64x2_t arg1;
      float64x2_t arg2;
      float64x2_t arg3;
      float64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"mls_lane\", fnname = \"vfmsq_laneq_f64\", rettype = \"float64x2_t\", argtypes = \"[float64x2_t,float64x2_t,float64x2_t,__constrange(0,1) int]\", vals = [VectorVal [FloatVal 0.5876887837086054,FloatVal 0.28944093750335664],VectorVal [FloatVal 0.8125864260779938,FloatVal 0.7214319037985424],VectorVal [FloatVal 0.5762465896481197,FloatVal 0.9638763157784964],IndexVal 1], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_f64(vcreate_f64(UINT64_C(0x3fe2ce58b54824af)),
                          vcreate_f64(UINT64_C(0x3fd28633482cd4f0)));
      arg2 = vcombine_f64(vcreate_f64(UINT64_C(0x3fea00b53fa5b650)),
                          vcreate_f64(UINT64_C(0x3fe715f85c23625e)));
      arg3 = vcombine_f64(vcreate_f64(UINT64_C(0x3fe2709cb01f0bee)),
                          vcreate_f64(UINT64_C(0x3feed81324b50b26)));
      clear_neon_saturated();
      //  Expect: "result" = bfd9fac29c7ef60abfc9079630416e34
      result = vfmsq_laneq_f64(arg1, arg2, arg3, 1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float64_t got;
         float64_t exp;
         got = vgetq_lane_f64(result, 0);
         exp = -0.19554402691106676;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float64_t got;
         float64_t exp;
         got = vgetq_lane_f64(result, 1);
         exp = -0.4059301880150491;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
   }
}
}
void dotests_2422() {

{
   {
      float32_t arg1;
      float32_t arg2;
      float32x2_t arg3;
      float32_t result;
      char* str1 = "ReproInfo2 {semantics = \"mls_lane\", fnname = \"vfmss_lane_f32\", rettype = \"float32_t\", argtypes = \"[float32_t,float32_t,float32x2_t,__constrange(0,1) int]\", vals = [FloatVal 0.7203434705734253,FloatVal 0.7475776076316833,VectorVal [FloatVal 0.13399022817611694,FloatVal 0.24942409992218018],IndexVal 1], start_saturated = False}";
      int reported = 0;
      float32_t got;
      float32_t exp;
      arg1 = ((float32_t) 0.7203434705734253);
      arg2 = ((float32_t) 0.7475776076316833);
      arg3 = vcreate_f32(UINT64_C(0x3e7f69083e0934bc));
      clear_neon_saturated();
      //  Expect: "result" = 3f08ac55
      result = vfmss_lane_f32(arg1, arg2, arg3, 1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = ((float32_t) 0.5338795781135559);
      if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %f Got: %f\n", "   ", exp, got);
         }
   }
}
}
void dotests_2423() {

{
   {
      float32_t arg1;
      float32_t arg2;
      float32x4_t arg3;
      float32_t result;
      char* str1 = "ReproInfo2 {semantics = \"mls_lane\", fnname = \"vfmss_laneq_f32\", rettype = \"float32_t\", argtypes = \"[float32_t,float32_t,float32x4_t,__constrange(0,3) int]\", vals = [FloatVal 0.17752236127853394,FloatVal 0.5234742164611816,VectorVal [FloatVal 0.39969128370285034,FloatVal 0.9202080368995667,FloatVal 0.6649443507194519,FloatVal 0.681300938129425],IndexVal 3], start_saturated = False}";
      int reported = 0;
      float32_t got;
      float32_t exp;
      arg1 = ((float32_t) 0.17752236127853394);
      arg2 = ((float32_t) 0.5234742164611816);
      arg3 = vcombine_f32(vcreate_f32(UINT64_C(0x3f6b92c13ecca456)),
                          vcreate_f32(UINT64_C(0x3f2e69bd3f2a39cb)));
      clear_neon_saturated();
      //  Expect: "result" = be376b86
      result = vfmss_laneq_f32(arg1, arg2, arg3, 3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = ((float32_t) -0.17912110686302185);
      if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %f Got: %f\n", "   ", exp, got);
         }
   }
}
}
void dotests_2424() {

{
   {
      float64_t arg1;
      float64_t arg2;
      float64x1_t arg3;
      float64_t result;
      char* str1 = "ReproInfo2 {semantics = \"mls_lane\", fnname = \"vfmsd_lane_f64\", rettype = \"float64_t\", argtypes = \"[float64_t,float64_t,float64x1_t,__constrange(0,0) int]\", vals = [FloatVal 0.6938113729793653,FloatVal 0.8154606999793418,VectorVal [FloatVal 0.20269336172699393],IndexVal 0], start_saturated = False}";
      int reported = 0;
      float64_t got;
      float64_t exp;
      arg1 = 0.6938113729793653;
      arg2 = 0.8154606999793418;
      arg3 = vcreate_f64(UINT64_C(0x3fc9f1db27ddeb18));
      clear_neon_saturated();
      //  Expect: "result" = 3fe0e9a8dc982f72
      result = vfmsd_lane_f64(arg1, arg2, arg3, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = 0.528522902344305;
      if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %f Got: %f\n", "   ", exp, got);
         }
   }
}
}
void dotests_2425() {

{
   {
      float64_t arg1;
      float64_t arg2;
      float64x2_t arg3;
      float64_t result;
      char* str1 = "ReproInfo2 {semantics = \"mls_lane\", fnname = \"vfmsd_laneq_f64\", rettype = \"float64_t\", argtypes = \"[float64_t,float64_t,float64x2_t,__constrange(0,1) int]\", vals = [FloatVal 0.815979848216774,FloatVal 0.5969459102529394,VectorVal [FloatVal 2.7437887381609016e-2,FloatVal 0.7298595298015247],IndexVal 0], start_saturated = False}";
      int reported = 0;
      float64_t got;
      float64_t exp;
      arg1 = 0.815979848216774;
      arg2 = 0.5969459102529394;
      arg3 = vcombine_f64(vcreate_f64(UINT64_C(0x3f9c18ad73e6c000)),
                          vcreate_f64(UINT64_C(0x3fe75b025f657cd0)));
      clear_neon_saturated();
      //  Expect: "result" = 3fe99654a7b2b6b1
      result = vfmsd_laneq_f64(arg1, arg2, arg3, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = 0.7996009135583418;
      if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %f Got: %f\n", "   ", exp, got);
         }
   }
}
}
void dotests_2426() {

{
   {
      float32x2_t arg1;
      float32x2_t arg2;
      float32x2_t arg3;
      float32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"mls_lane\", fnname = \"vmls_lane_f32\", rettype = \"float32x2_t\", argtypes = \"[float32x2_t,float32x2_t,float32x2_t,__constrange(0,1) int]\", vals = [VectorVal [FloatVal 0.21330022811889648,FloatVal 0.1519206166267395],VectorVal [FloatVal 1.5247762203216553e-2,FloatVal 0.9039456844329834],VectorVal [FloatVal 0.17972129583358765,FloatVal 0.7167121767997742],IndexVal 1], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_f32(UINT64_C(0x3e1b91143e5a6b60));
      arg2 = vcreate_f32(UINT64_C(0x3f6768fc3c79d1c0));
      arg3 = vcreate_f32(UINT64_C(0x3f377a733e3808dc));
      clear_neon_saturated();
      //  Expect: "result" = befdecee3e4f3a99
      result = vmls_lane_f32(arg1, arg2, arg3, 1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result, 0);
         exp = ((float32_t) 0.2023719698190689);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result, 1);
         exp = ((float32_t) -0.49594825506210327);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
   }
}
}
void dotests_2427() {

{
   {
      float32x2_t arg1;
      float32x2_t arg2;
      float32x4_t arg3;
      float32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"mls_lane\", fnname = \"vmls_laneq_f32\", rettype = \"float32x2_t\", argtypes = \"[float32x2_t,float32x2_t,float32x4_t,__constrange(0,3) int]\", vals = [VectorVal [FloatVal 0.29114675521850586,FloatVal 0.5988091826438904],VectorVal [FloatVal 0.7031921148300171,FloatVal 0.48212796449661255],VectorVal [FloatVal 0.48444294929504395,FloatVal 0.46510040760040283,FloatVal 2.9758453369140625e-2,FloatVal 0.261447548866272],IndexVal 1], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_f32(UINT64_C(0x3f194b8f3e951130));
      arg2 = vcreate_f32(UINT64_C(0x3ef6d97a3f340466));
      arg3 = vcombine_f32(vcreate_f32(UINT64_C(0x3eee21a43ef808e8)),
                          vcreate_f32(UINT64_C(0x3e85dc743cf3c800)));
      clear_neon_saturated();
      //  Expect: "result" = 3ebfc7cebd131476
      result = vmls_laneq_f32(arg1, arg2, arg3, 1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result, 0);
         exp = ((float32_t) -3.5908184945583344e-2);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result, 1);
         exp = ((float32_t) 0.3745712637901306);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
   }
}
}
void dotests_2428() {

{
   {
      float32x4_t arg1;
      float32x4_t arg2;
      float32x2_t arg3;
      float32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"mls_lane\", fnname = \"vmlsq_lane_f32\", rettype = \"float32x4_t\", argtypes = \"[float32x4_t,float32x4_t,float32x2_t,__constrange(0,1) int]\", vals = [VectorVal [FloatVal 0.5166869759559631,FloatVal 0.31815505027770996,FloatVal 0.38137298822402954,FloatVal 0.16588234901428223],VectorVal [FloatVal 0.12012946605682373,FloatVal 0.10159027576446533,FloatVal 1.859503984451294e-2,FloatVal 0.8282568454742432],VectorVal [FloatVal 0.8134570717811584,FloatVal 0.618090808391571],IndexVal 0], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_f32(vcreate_f32(UINT64_C(0x3ea2e5383f044599)),
                          vcreate_f32(UINT64_C(0x3e29dd103ec34352)));
      arg2 = vcombine_f32(vcreate_f32(UINT64_C(0x3dd00e903df60670)),
                          vcreate_f32(UINT64_C(0x3f5408a43c9854a0)));
      arg3 = vcreate_f32(UINT64_C(0x3f1e3b333f503eb9));
      clear_neon_saturated();
      //  Expect: "result" = bf0203b53ebb84b13e712b093ed682d1
      result = vmlsq_lane_f32(arg1, arg2, arg3, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 0);
         exp = ((float32_t) 0.41896679997444153);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 1);
         exp = ((float32_t) 0.23551572859287262);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 2);
         exp = ((float32_t) 0.3662467300891876);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 2 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 3);
         exp = ((float32_t) -0.5078690648078918);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 3 ", exp, got);
            }
      }
   }
}
}
void dotests_2429() {

{
   {
      float32x4_t arg1;
      float32x4_t arg2;
      float32x4_t arg3;
      float32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"mls_lane\", fnname = \"vmlsq_laneq_f32\", rettype = \"float32x4_t\", argtypes = \"[float32x4_t,float32x4_t,float32x4_t,__constrange(0,3) int]\", vals = [VectorVal [FloatVal 0.11003786325454712,FloatVal 3.7335753440856934e-3,FloatVal 9.15418267250061e-2,FloatVal 0.626940131187439],VectorVal [FloatVal 0.7793318033218384,FloatVal 0.7134150862693787,FloatVal 0.8030619025230408,FloatVal 0.7789877653121948],VectorVal [FloatVal 0.9870040416717529,FloatVal 0.42647677659988403,FloatVal 0.6973015069961548,FloatVal 0.7570799589157104],IndexVal 3], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_f32(vcreate_f32(UINT64_C(0x3b74af003de15b88)),
                          vcreate_f32(UINT64_C(0x3f207f263dbb7a48)));
      arg2 = vcombine_f32(vcreate_f32(UINT64_C(0x3f36a25f3f47824a)),
                          vcreate_f32(UINT64_C(0x3f476bbe3f4d9577)));
      arg3 = vcombine_f32(vcreate_f32(UINT64_C(0x3eda5b2a3f7cac4c)),
                          vcreate_f32(UINT64_C(0x3f41cffe3f32825a)));
      clear_neon_saturated();
      //  Expect: "result" = 3d184e5cbf04356ebf09501dbef5bfc2
      result = vmlsq_laneq_f32(arg1, arg2, arg3, 3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 0);
         exp = ((float32_t) -0.47997862100601196);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 1);
         exp = ((float32_t) -0.5363786816596985);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 2);
         exp = ((float32_t) -0.5164402723312378);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 2 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 3);
         exp = ((float32_t) 3.7184104323387146e-2);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 3 ", exp, got);
            }
      }
   }
}
}
void dotests_2430() {

{
   {
      int32x4_t arg1;
      int16x4_t arg2;
      int16x4_t arg3;
      int32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"mla_lane\", fnname = \"vmlal_lane_s16\", rettype = \"int32x4_t\", argtypes = \"[int32x4_t,int16x4_t,int16x4_t,__constrange(0,3) int]\", vals = [VectorVal [IntegerVal (-32769),IntegerVal 19439,IntegerVal (-2147450880),IntegerVal (-2147433727)],VectorVal [IntegerVal 32767,IntegerVal 0,IntegerVal (-12832),IntegerVal (-18654)],VectorVal [IntegerVal 0,IntegerVal (-1),IntegerVal 32767,IntegerVal 0],IndexVal 2], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s32(vcreate_s32(UINT64_C(0x00004befffff7fff)),
                          vcreate_s32(UINT64_C(0x8000c30180008000)));
      arg2 = vcreate_s16(UINT64_C(0xb722cde000007fff));
      arg3 = vcreate_s16(UINT64_C(0x00007fffffff0000));
      clear_neon_saturated();
      //  Expect: "result" = 5b920bdf66f0b22000004bef3ffe8000
      result = vmlal_lane_s16(arg1, arg2, arg3, 2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 0);
         exp = UINT64_C(0x00004bef3ffe8000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 1);
         exp = UINT64_C(0x5b920bdf66f0b220);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2431() {

{
   {
      int32x4_t arg1;
      int16x4_t arg2;
      int16x8_t arg3;
      int32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"mla_lane\", fnname = \"vmlal_laneq_s16\", rettype = \"int32x4_t\", argtypes = \"[int32x4_t,int16x4_t,int16x8_t,__constrange(0,7) int]\", vals = [VectorVal [IntegerVal 65535,IntegerVal 2147457992,IntegerVal (-2147418113),IntegerVal (-2147483648)],VectorVal [IntegerVal (-32768),IntegerVal 32767,IntegerVal (-23810),IntegerVal 28385],VectorVal [IntegerVal 3287,IntegerVal (-1),IntegerVal (-1),IntegerVal 32767,IntegerVal 0,IntegerVal (-31399),IntegerVal 32767,IntegerVal 0],IndexVal 6], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s32(vcreate_s32(UINT64_C(0x7fff9bc80000ffff)),
                          vcreate_s32(UINT64_C(0x800000008000ffff)));
      arg2 = vcreate_s16(UINT64_C(0x6ee1a2fe7fff8000));
      arg3 = vcombine_s16(vcreate_s16(UINT64_C(0x7fffffffffff0cd7)),
                          vcreate_s16(UINT64_C(0x00007fff85590000)));
      clear_neon_saturated();
      //  Expect: "result" = b770111f51805d01bffe9bc9c0017fff
      result = vmlal_laneq_s16(arg1, arg2, arg3, 6);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 0);
         exp = UINT64_C(0xbffe9bc9c0017fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 1);
         exp = UINT64_C(0xb770111f51805d01);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2432() {

{
   {
      int32x4_t arg1;
      int16x8_t arg2;
      int16x4_t arg3;
      int32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"mla_lane\", fnname = \"vmlal_high_lane_s16\", rettype = \"int32x4_t\", argtypes = \"[int32x4_t,int16x8_t,int16x4_t,__constrange(0,3) int]\", vals = [VectorVal [IntegerVal 2147435482,IntegerVal (-2147418113),IntegerVal (-1063649280),IntegerVal (-2147421507)],VectorVal [IntegerVal (-13852),IntegerVal (-32768),IntegerVal (-28718),IntegerVal 32767,IntegerVal 32767,IntegerVal 32767,IntegerVal (-1),IntegerVal 0],VectorVal [IntegerVal (-1),IntegerVal 11590,IntegerVal (-4698),IntegerVal (-32768)],IndexVal 0], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s32(vcreate_s32(UINT64_C(0x8000ffff7fff43da)),
                          vcreate_s32(UINT64_C(0x8000f2bdc09a0000)));
      arg2 = vcombine_s16(vcreate_s16(UINT64_C(0x7fff8fd28000c9e4)),
                          vcreate_s16(UINT64_C(0x0000ffff7fff7fff)));
      arg3 = vcreate_s16(UINT64_C(0x8000eda62d46ffff));
      clear_neon_saturated();
      //  Expect: "result" = 8000f2bdc09a0001800080007ffec3db
      result = vmlal_high_lane_s16(arg1, arg2, arg3, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 0);
         exp = UINT64_C(0x800080007ffec3db);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 1);
         exp = UINT64_C(0x8000f2bdc09a0001);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2433() {

{
   {
      int32x4_t arg1;
      int16x8_t arg2;
      int16x8_t arg3;
      int32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"mla_lane\", fnname = \"vmlal_high_laneq_s16\", rettype = \"int32x4_t\", argtypes = \"[int32x4_t,int16x8_t,int16x8_t,__constrange(0,7) int]\", vals = [VectorVal [IntegerVal (-2147418113),IntegerVal 65535,IntegerVal 1623236062,IntegerVal (-811106305)],VectorVal [IntegerVal 0,IntegerVal (-32768),IntegerVal 0,IntegerVal 32767,IntegerVal 0,IntegerVal (-32768),IntegerVal (-1),IntegerVal (-32768)],VectorVal [IntegerVal 0,IntegerVal 20137,IntegerVal (-32768),IntegerVal 32767,IntegerVal (-1),IntegerVal 0,IntegerVal (-1),IntegerVal 0],IndexVal 7], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s32(vcreate_s32(UINT64_C(0x0000ffff8000ffff)),
                          vcreate_s32(UINT64_C(0xcfa77fff60c09dde)));
      arg2 = vcombine_s16(vcreate_s16(UINT64_C(0x7fff000080000000)),
                          vcreate_s16(UINT64_C(0x8000ffff80000000)));
      arg3 = vcombine_s16(vcreate_s16(UINT64_C(0x7fff80004ea90000)),
                          vcreate_s16(UINT64_C(0x0000ffff0000ffff)));
      clear_neon_saturated();
      //  Expect: "result" = cfa77fff60c09dde0000ffff8000ffff
      result = vmlal_high_laneq_s16(arg1, arg2, arg3, 7);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 0);
         exp = UINT64_C(0x0000ffff8000ffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 1);
         exp = UINT64_C(0xcfa77fff60c09dde);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2434() {

{
   {
      int64x2_t arg1;
      int32x2_t arg2;
      int32x2_t arg3;
      int64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"mla_lane\", fnname = \"vmlal_lane_s32\", rettype = \"int64x2_t\", argtypes = \"[int64x2_t,int32x2_t,int32x2_t,__constrange(0,1) int]\", vals = [VectorVal [IntegerVal (-3780208939371593728),IntegerVal (-2409285062658392065)],VectorVal [IntegerVal (-2147483648),IntegerVal (-1)],VectorVal [IntegerVal (-32769),IntegerVal (-1507681252)],IndexVal 0], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s64(vcreate_s64(UINT64_C(0xcb89ffff80000000)),
                          vcreate_s64(UINT64_C(0xde9080001d977fff)));
      arg2 = vcreate_s32(UINT64_C(0xffffffff80000000));
      arg3 = vcreate_s32(UINT64_C(0xa6229c1cffff7fff));
      clear_neon_saturated();
      //  Expect: "result" = de9080001d980000cb8a400000000000
      result = vmlal_lane_s32(arg1, arg2, arg3, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 0);
         exp = UINT64_C(0xcb8a400000000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 1);
         exp = UINT64_C(0xde9080001d980000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2435() {

{
   {
      int64x2_t arg1;
      int32x2_t arg2;
      int32x4_t arg3;
      int64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"mla_lane\", fnname = \"vmlal_laneq_s32\", rettype = \"int64x2_t\", argtypes = \"[int64x2_t,int32x2_t,int32x4_t,__constrange(0,3) int]\", vals = [VectorVal [IntegerVal 209124105181085,IntegerVal 9223231301513936896],VectorVal [IntegerVal (-2147450880),IntegerVal 2147418112],VectorVal [IntegerVal 65535,IntegerVal 2147418112,IntegerVal 41965,IntegerVal 0],IndexVal 2], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s64(vcreate_s64(UINT64_C(0x0000be328000d79d)),
                          vcreate_s64(UINT64_C(0x7fff800080008000)));
      arg2 = vcreate_s32(UINT64_C(0x7fff000080008000));
      arg3 = vcombine_s32(vcreate_s32(UINT64_C(0x7fff00000000ffff)),
                          vcreate_s32(UINT64_C(0x000000000000a3ed)));
      clear_neon_saturated();
      //  Expect: "result" = 7fffd1f65c13800000006c3c51f7579d
      result = vmlal_laneq_s32(arg1, arg2, arg3, 2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 0);
         exp = UINT64_C(0x00006c3c51f7579d);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 1);
         exp = UINT64_C(0x7fffd1f65c138000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2436() {

{
   {
      int64x2_t arg1;
      int32x4_t arg2;
      int32x2_t arg3;
      int64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"mla_lane\", fnname = \"vmlal_high_lane_s32\", rettype = \"int64x2_t\", argtypes = \"[int64x2_t,int32x4_t,int32x2_t,__constrange(0,1) int]\", vals = [VectorVal [IntegerVal (-281472829194241),IntegerVal 140741781454848],VectorVal [IntegerVal (-773095424),IntegerVal 2147450880,IntegerVal (-32768),IntegerVal 2147450879],VectorVal [IntegerVal 32768,IntegerVal 65535],IndexVal 0], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s64(vcreate_s64(UINT64_C(0xffff000080007fff)),
                          vcreate_s64(UINT64_C(0x00008000ffe38000)));
      arg2 = vcombine_s32(vcreate_s32(UINT64_C(0x7fff8000d1eb8000)),
                          vcreate_s32(UINT64_C(0x7fff7fffffff8000)));
      arg3 = vcreate_s32(UINT64_C(0x0000ffff00008000));
      clear_neon_saturated();
      //  Expect: "result" = 0000c000bfe30000ffff000040007fff
      result = vmlal_high_lane_s32(arg1, arg2, arg3, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 0);
         exp = UINT64_C(0xffff000040007fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 1);
         exp = UINT64_C(0x0000c000bfe30000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2437() {

{
   {
      int64x2_t arg1;
      int32x4_t arg2;
      int32x4_t arg3;
      int64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"mla_lane\", fnname = \"vmlal_high_laneq_s32\", rettype = \"int64x2_t\", argtypes = \"[int64x2_t,int32x4_t,int32x4_t,__constrange(0,3) int]\", vals = [VectorVal [IntegerVal 2147507628,IntegerVal (-9223231295071453185)],VectorVal [IntegerVal 0,IntegerVal (-32768),IntegerVal 2147418112,IntegerVal (-40659)],VectorVal [IntegerVal (-32768),IntegerVal (-1),IntegerVal 30486,IntegerVal 2147450879],IndexVal 0], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s64(vcreate_s64(UINT64_C(0x0000000080005dac)),
                          vcreate_s64(UINT64_C(0x80008000ffffffff)));
      arg2 = vcombine_s32(vcreate_s32(UINT64_C(0xffff800000000000)),
                          vcreate_s32(UINT64_C(0xffff612d7fff0000)));
      arg3 = vcombine_s32(vcreate_s32(UINT64_C(0xffffffffffff8000)),
                          vcreate_s32(UINT64_C(0x7fff7fff00007716)));
      clear_neon_saturated();
      //  Expect: "result" = 800080014f697fffffffc00100005dac
      result = vmlal_high_laneq_s32(arg1, arg2, arg3, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 0);
         exp = UINT64_C(0xffffc00100005dac);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 1);
         exp = UINT64_C(0x800080014f697fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2438() {

{
   {
      uint32x4_t arg1;
      uint16x4_t arg2;
      uint16x4_t arg3;
      uint32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"mla_lane\", fnname = \"vmlal_lane_u16\", rettype = \"uint32x4_t\", argtypes = \"[uint32x4_t,uint16x4_t,uint16x4_t,__constrange(0,3) int]\", vals = [VectorVal [IntegerVal 4294934527,IntegerVal 2147450880,IntegerVal 2147516415,IntegerVal 2147549183],VectorVal [IntegerVal 32767,IntegerVal 32767,IntegerVal 65535,IntegerVal 65535],VectorVal [IntegerVal 65535,IntegerVal 57358,IntegerVal 0,IntegerVal 0],IndexVal 2], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u32(vcreate_u32(UINT64_C(0x7fff8000ffff7fff)),
                          vcreate_u32(UINT64_C(0x8000ffff80007fff)));
      arg2 = vcreate_u16(UINT64_C(0xffffffff7fff7fff));
      arg3 = vcreate_u16(UINT64_C(0x00000000e00effff));
      clear_neon_saturated();
      //  Expect: "result" = 8000ffff80007fff7fff8000ffff7fff
      result = vmlal_lane_u16(arg1, arg2, arg3, 2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 0);
         exp = UINT64_C(0x7fff8000ffff7fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 1);
         exp = UINT64_C(0x8000ffff80007fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2439() {

{
   {
      uint32x4_t arg1;
      uint16x4_t arg2;
      uint16x8_t arg3;
      uint32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"mla_lane\", fnname = \"vmlal_laneq_u16\", rettype = \"uint32x4_t\", argtypes = \"[uint32x4_t,uint16x4_t,uint16x8_t,__constrange(0,7) int]\", vals = [VectorVal [IntegerVal 2147431567,IntegerVal 0,IntegerVal 2147549183,IntegerVal 0],VectorVal [IntegerVal 0,IntegerVal 65535,IntegerVal 32768,IntegerVal 65535],VectorVal [IntegerVal 47392,IntegerVal 32767,IntegerVal 32767,IntegerVal 32767,IntegerVal 32768,IntegerVal 9875,IntegerVal 50646,IntegerVal 65535],IndexVal 6], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u32(vcreate_u32(UINT64_C(0x000000007fff348f)),
                          vcreate_u32(UINT64_C(0x000000008000ffff)));
      arg2 = vcreate_u16(UINT64_C(0xffff8000ffff0000));
      arg3 = vcombine_u16(vcreate_u16(UINT64_C(0x7fff7fff7fffb920)),
                          vcreate_u16(UINT64_C(0xffffc5d626938000)));
      clear_neon_saturated();
      //  Expect: "result" = c5d53a2ae2ebffffc5d53a2a7fff348f
      result = vmlal_laneq_u16(arg1, arg2, arg3, 6);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 0);
         exp = UINT64_C(0xc5d53a2a7fff348f);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 1);
         exp = UINT64_C(0xc5d53a2ae2ebffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2440() {

{
   {
      uint32x4_t arg1;
      uint16x8_t arg2;
      uint16x4_t arg3;
      uint32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"mla_lane\", fnname = \"vmlal_high_lane_u16\", rettype = \"uint32x4_t\", argtypes = \"[uint32x4_t,uint16x8_t,uint16x4_t,__constrange(0,3) int]\", vals = [VectorVal [IntegerVal 2924085247,IntegerVal 994530041,IntegerVal 2147450880,IntegerVal 4294967295],VectorVal [IntegerVal 46712,IntegerVal 32767,IntegerVal 32768,IntegerVal 65535,IntegerVal 21543,IntegerVal 32768,IntegerVal 0,IntegerVal 65535],VectorVal [IntegerVal 59142,IntegerVal 32767,IntegerVal 0,IntegerVal 0],IndexVal 2], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u32(vcreate_u32(UINT64_C(0x3b4752f9ae49ffff)),
                          vcreate_u32(UINT64_C(0xffffffff7fff8000)));
      arg2 = vcombine_u16(vcreate_u16(UINT64_C(0xffff80007fffb678)),
                          vcreate_u16(UINT64_C(0xffff000080005427)));
      arg3 = vcreate_u16(UINT64_C(0x000000007fffe706));
      clear_neon_saturated();
      //  Expect: "result" = ffffffff7fff80003b4752f9ae49ffff
      result = vmlal_high_lane_u16(arg1, arg2, arg3, 2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 0);
         exp = UINT64_C(0x3b4752f9ae49ffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 1);
         exp = UINT64_C(0xffffffff7fff8000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2441() {

{
   {
      uint32x4_t arg1;
      uint16x8_t arg2;
      uint16x8_t arg3;
      uint32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"mla_lane\", fnname = \"vmlal_high_laneq_u16\", rettype = \"uint32x4_t\", argtypes = \"[uint32x4_t,uint16x8_t,uint16x8_t,__constrange(0,7) int]\", vals = [VectorVal [IntegerVal 4294901760,IntegerVal 905805824,IntegerVal 4294908076,IntegerVal 2147450880],VectorVal [IntegerVal 0,IntegerVal 32768,IntegerVal 32767,IntegerVal 32767,IntegerVal 0,IntegerVal 0,IntegerVal 5729,IntegerVal 65535],VectorVal [IntegerVal 0,IntegerVal 32767,IntegerVal 32768,IntegerVal 32768,IntegerVal 65535,IntegerVal 0,IntegerVal 65535,IntegerVal 32767],IndexVal 7], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u32(vcreate_u32(UINT64_C(0x35fd8000ffff0000)),
                          vcreate_u32(UINT64_C(0x7fff8000ffff18ac)));
      arg2 = vcombine_u16(vcreate_u16(UINT64_C(0x7fff7fff80000000)),
                          vcreate_u16(UINT64_C(0xffff166100000000)));
      arg3 = vcombine_u16(vcreate_u16(UINT64_C(0x800080007fff0000)),
                          vcreate_u16(UINT64_C(0x7fffffff0000ffff)));
      clear_neon_saturated();
      //  Expect: "result" = fffe00010b2f824b35fd8000ffff0000
      result = vmlal_high_laneq_u16(arg1, arg2, arg3, 7);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 0);
         exp = UINT64_C(0x35fd8000ffff0000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 1);
         exp = UINT64_C(0xfffe00010b2f824b);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2442() {

{
   {
      uint64x2_t arg1;
      uint32x2_t arg2;
      uint32x2_t arg3;
      uint64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"mla_lane\", fnname = \"vmlal_lane_u32\", rettype = \"uint64x2_t\", argtypes = \"[uint64x2_t,uint32x2_t,uint32x2_t,__constrange(0,1) int]\", vals = [VectorVal [IntegerVal 8378384154621902847,IntegerVal 9223231297409712127],VectorVal [IntegerVal 2147450880,IntegerVal 2147516416],VectorVal [IntegerVal 4294967295,IntegerVal 4294967295],IndexVal 1], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u64(vcreate_u64(UINT64_C(0x7445ffff7fffffff)),
                          vcreate_u64(UINT64_C(0x7fff7fff8b5effff)));
      arg2 = vcreate_u32(UINT64_C(0x800080007fff8000));
      arg3 = vcreate_u32(UINT64_C(0xffffffffffffffff));
      clear_neon_saturated();
      //  Expect: "result" = ffffffff0b5e7ffff4457fff00007fff
      result = vmlal_lane_u32(arg1, arg2, arg3, 1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 0);
         exp = UINT64_C(0xf4457fff00007fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 1);
         exp = UINT64_C(0xffffffff0b5e7fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2443() {

{
   {
      uint64x2_t arg1;
      uint32x2_t arg2;
      uint32x4_t arg3;
      uint64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"mla_lane\", fnname = \"vmlal_laneq_u32\", rettype = \"uint64x2_t\", argtypes = \"[uint64x2_t,uint32x2_t,uint32x4_t,__constrange(0,3) int]\", vals = [VectorVal [IntegerVal 9223653507998842880,IntegerVal 281470681796807],VectorVal [IntegerVal 4294960638,IntegerVal 4294901760],VectorVal [IntegerVal 2147516415,IntegerVal 65535,IntegerVal 38510,IntegerVal 4294934528],IndexVal 3], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u64(vcreate_u64(UINT64_C(0x8000ffff1b8e8000)),
                          vcreate_u64(UINT64_C(0x0000ffff0000d0c7)));
      arg2 = vcreate_u32(UINT64_C(0xffff0000ffffe5fe));
      arg3 = vcombine_u32(vcreate_u32(UINT64_C(0x0000ffff80007fff)),
                          vcreate_u32(UINT64_C(0xffff80000000966e)));
      clear_neon_saturated();
      //  Expect: "result" = ffff7fff8000d0c7800065fd288f8000
      result = vmlal_laneq_u32(arg1, arg2, arg3, 3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 0);
         exp = UINT64_C(0x800065fd288f8000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 1);
         exp = UINT64_C(0xffff7fff8000d0c7);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2444() {

{
   {
      uint64x2_t arg1;
      uint32x4_t arg2;
      uint32x2_t arg3;
      uint64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"mla_lane\", fnname = \"vmlal_high_lane_u32\", rettype = \"uint64x2_t\", argtypes = \"[uint64x2_t,uint32x4_t,uint32x2_t,__constrange(0,1) int]\", vals = [VectorVal [IntegerVal 9223090564025548800,IntegerVal 9223231297218996152],VectorVal [IntegerVal 4294967295,IntegerVal 2147483647,IntegerVal 4294967295,IntegerVal 2147515042],VectorVal [IntegerVal 2147450879,IntegerVal 2147516415],IndexVal 1], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u64(vcreate_u64(UINT64_C(0x7fff000080000000)),
                          vcreate_u64(UINT64_C(0x7fff7fff8000e7b8)));
      arg2 = vcombine_u32(vcreate_u32(UINT64_C(0x7fffffffffffffff)),
                          vcreate_u32(UINT64_C(0x80007aa2ffffffff)));
      arg3 = vcreate_u32(UINT64_C(0x80007fff7fff7fff));
      clear_neon_saturated();
      //  Expect: "result" = bffffd503d516d16ffff7ffeffff8001
      result = vmlal_high_lane_u32(arg1, arg2, arg3, 1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 0);
         exp = UINT64_C(0xffff7ffeffff8001);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 1);
         exp = UINT64_C(0xbffffd503d516d16);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2445() {

{
   {
      uint64x2_t arg1;
      uint32x4_t arg2;
      uint32x4_t arg3;
      uint64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"mla_lane\", fnname = \"vmlal_high_laneq_u32\", rettype = \"uint64x2_t\", argtypes = \"[uint64x2_t,uint32x4_t,uint32x4_t,__constrange(0,3) int]\", vals = [VectorVal [IntegerVal 231090958026886873,IntegerVal 18446744069414584320],VectorVal [IntegerVal 2147483648,IntegerVal 4294961032,IntegerVal 2147450880,IntegerVal 32767],VectorVal [IntegerVal 65535,IntegerVal 65535,IntegerVal 3690491316,IntegerVal 2147483648],IndexVal 1], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u64(vcreate_u64(UINT64_C(0x033500007fff4ed9)),
                          vcreate_u64(UINT64_C(0xffffffff00000000)));
      arg2 = vcombine_u32(vcreate_u32(UINT64_C(0xffffe78880000000)),
                          vcreate_u32(UINT64_C(0x00007fff7fff8000)));
      arg3 = vcombine_u32(vcreate_u32(UINT64_C(0x0000ffff0000ffff)),
                          vcreate_u32(UINT64_C(0x80000000dbf86db4)));
      clear_neon_saturated();
      //  Expect: "result" = ffffffff7ffe800103357fff7fffced9
      result = vmlal_high_laneq_u32(arg1, arg2, arg3, 1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 0);
         exp = UINT64_C(0x03357fff7fffced9);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 1);
         exp = UINT64_C(0xffffffff7ffe8001);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2446() {

{
   {
      int32x4_t arg1;
      int16x4_t arg2;
      int16x4_t arg3;
      int32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"qdmla_lane\", fnname = \"vqdmlal_lane_s16\", rettype = \"int32x4_t\", argtypes = \"[int32x4_t,int16x4_t,int16x4_t,__constrange(0,3) int]\", vals = [VectorVal [IntegerVal 65535,IntegerVal (-2147483648),IntegerVal 834306047,IntegerVal (-32768)],VectorVal [IntegerVal (-12840),IntegerVal 32767,IntegerVal (-24294),IntegerVal 26716],VectorVal [IntegerVal 0,IntegerVal (-1),IntegerVal (-16307),IntegerVal (-26264)],IndexVal 2], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s32(vcreate_s32(UINT64_C(0x800000000000ffff)),
                          vcreate_s32(UINT64_C(0xffff800031ba7fff)));
      arg2 = vcreate_s16(UINT64_C(0x685ca11a7fffcdd8));
      arg3 = vcreate_s16(UINT64_C(0x9968c04dffff0000));
      clear_neon_saturated();
      //  Expect: "result" = cc10475860f469a38000000018f6d3ef
      result = vqdmlal_lane_s16(arg1, arg2, arg3, 2);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 0);
         exp = UINT64_C(0x8000000018f6d3ef);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 1);
         exp = UINT64_C(0xcc10475860f469a3);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2447() {

{
   {
      int32x4_t arg1;
      int16x4_t arg2;
      int16x8_t arg3;
      int32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"qdmla_lane\", fnname = \"vqdmlal_laneq_s16\", rettype = \"int32x4_t\", argtypes = \"[int32x4_t,int16x4_t,int16x8_t,__constrange(0,7) int]\", vals = [VectorVal [IntegerVal (-2147450881),IntegerVal (-2147450880),IntegerVal 2147450880,IntegerVal (-1736671232)],VectorVal [IntegerVal 32767,IntegerVal (-1),IntegerVal 0,IntegerVal 0],VectorVal [IntegerVal 0,IntegerVal (-32768),IntegerVal 0,IntegerVal (-1),IntegerVal 0,IntegerVal 20285,IntegerVal 32767,IntegerVal 0],IndexVal 2], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s32(vcreate_s32(UINT64_C(0x8000800080007fff)),
                          vcreate_s32(UINT64_C(0x987c80007fff8000)));
      arg2 = vcreate_s16(UINT64_C(0x00000000ffff7fff));
      arg3 = vcombine_s16(vcreate_s16(UINT64_C(0xffff000080000000)),
                          vcreate_s16(UINT64_C(0x00007fff4f3d0000)));
      clear_neon_saturated();
      //  Expect: "result" = 987c80007fff80008000800080007fff
      result = vqdmlal_laneq_s16(arg1, arg2, arg3, 2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 0);
         exp = UINT64_C(0x8000800080007fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 1);
         exp = UINT64_C(0x987c80007fff8000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2448() {

{
   {
      int32x4_t arg1;
      int16x8_t arg2;
      int16x4_t arg3;
      int32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"qdmla_lane\", fnname = \"vqdmlal_high_lane_s16\", rettype = \"int32x4_t\", argtypes = \"[int32x4_t,int16x8_t,int16x4_t,__constrange(0,3) int]\", vals = [VectorVal [IntegerVal 2147483647,IntegerVal (-658374657),IntegerVal 65535,IntegerVal 2147483423],VectorVal [IntegerVal 32767,IntegerVal 19037,IntegerVal 0,IntegerVal 0,IntegerVal 14787,IntegerVal 0,IntegerVal (-1),IntegerVal (-32768)],VectorVal [IntegerVal (-1),IntegerVal 32767,IntegerVal (-1),IntegerVal (-8782)],IndexVal 1], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s32(vcreate_s32(UINT64_C(0xd8c1ffff7fffffff)),
                          vcreate_s32(UINT64_C(0x7fffff1f0000ffff)));
      arg2 = vcombine_s16(vcreate_s16(UINT64_C(0x000000004a5d7fff)),
                          vcreate_s16(UINT64_C(0x8000ffff000039c3)));
      arg3 = vcreate_s16(UINT64_C(0xddb2ffff7fffffff));
      clear_neon_saturated();
      //  Expect: "result" = 0000ff1f00000001d8c1ffff7fffffff
      result = vqdmlal_high_lane_s16(arg1, arg2, arg3, 1);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 0);
         exp = UINT64_C(0xd8c1ffff7fffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 1);
         exp = UINT64_C(0x0000ff1f00000001);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2449() {

{
   {
      int32x4_t arg1;
      int16x8_t arg2;
      int16x8_t arg3;
      int32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"qdmla_lane\", fnname = \"vqdmlal_high_laneq_s16\", rettype = \"int32x4_t\", argtypes = \"[int32x4_t,int16x8_t,int16x8_t,__constrange(0,7) int]\", vals = [VectorVal [IntegerVal 32767,IntegerVal (-31031297),IntegerVal (-55687),IntegerVal 32768],VectorVal [IntegerVal 0,IntegerVal 4860,IntegerVal 0,IntegerVal 0,IntegerVal (-32768),IntegerVal 32767,IntegerVal (-18184),IntegerVal 32767],VectorVal [IntegerVal (-28991),IntegerVal (-32768),IntegerVal (-32464),IntegerVal 32767,IntegerVal 15013,IntegerVal 0,IntegerVal 29557,IntegerVal (-32768)],IndexVal 1], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s32(vcreate_s32(UINT64_C(0xfe267fff00007fff)),
                          vcreate_s32(UINT64_C(0x00008000ffff2679)));
      arg2 = vcombine_s16(vcreate_s16(UINT64_C(0x0000000012fc0000)),
                          vcreate_s16(UINT64_C(0x7fffb8f87fff8000)));
      arg3 = vcombine_s16(vcreate_s16(UINT64_C(0x7fff813080008ec1)),
                          vcreate_s16(UINT64_C(0x8000737500003aa5)));
      clear_neon_saturated();
      //  Expect: "result" = 8001800047072679800000007fffffff
      result = vqdmlal_high_laneq_s16(arg1, arg2, arg3, 1);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 0);
         exp = UINT64_C(0x800000007fffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 1);
         exp = UINT64_C(0x8001800047072679);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2450() {

{
   {
      int64x2_t arg1;
      int32x2_t arg2;
      int32x2_t arg3;
      int64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"qdmla_lane\", fnname = \"vqdmlal_lane_s32\", rettype = \"int64x2_t\", argtypes = \"[int64x2_t,int32x2_t,int32x2_t,__constrange(0,1) int]\", vals = [VectorVal [IntegerVal (-27245125074944),IntegerVal (-2147496238)],VectorVal [IntegerVal 32767,IntegerVal 2147421788],VectorVal [IntegerVal 15099,IntegerVal 2147450879],IndexVal 0], start_saturated = True}";
      int reported = 0;
      arg1 = vcombine_s64(vcreate_s64(UINT64_C(0xffffe7387fff8000)),
                          vcreate_s64(UINT64_C(0xffffffff7fffced2)));
      arg2 = vcreate_s32(UINT64_C(0x7fff0e5c00007fff));
      arg3 = vcreate_s32(UINT64_C(0x7fff7fff00003afb));
      set_neon_saturated();
      //  Expect: "result" = 00003afa10a7a73affffe738bafa0a0a
      result = vqdmlal_lane_s32(arg1, arg2, arg3, 0);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 0);
         exp = UINT64_C(0xffffe738bafa0a0a);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 1);
         exp = UINT64_C(0x00003afa10a7a73a);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2451() {

{
   {
      int64x2_t arg1;
      int32x2_t arg2;
      int32x4_t arg3;
      int64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"qdmla_lane\", fnname = \"vqdmlal_laneq_s32\", rettype = \"int64x2_t\", argtypes = \"[int64x2_t,int32x2_t,int32x4_t,__constrange(0,3) int]\", vals = [VectorVal [IntegerVal 9223090566172999680,IntegerVal (-164765682835895)],VectorVal [IntegerVal 2147418112,IntegerVal 65535],VectorVal [IntegerVal 945815552,IntegerVal 2147450879,IntegerVal (-2018084303),IntegerVal (-1464650948)],IndexVal 1], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s64(vcreate_s64(UINT64_C(0x7fff0000ffff8000)),
                          vcreate_s64(UINT64_C(0xffff6a258000de49)));
      arg2 = vcreate_s32(UINT64_C(0x0000ffff7fff0000));
      arg3 = vcombine_s32(vcreate_s32(UINT64_C(0x7fff7fff38600000)),
                          vcreate_s32(UINT64_C(0xa8b3333c87b67a31)));
      clear_neon_saturated();
      //  Expect: "result" = 00006a237fffde4b7fffffffffffffff
      result = vqdmlal_laneq_s32(arg1, arg2, arg3, 1);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 0);
         exp = UINT64_C(0x7fffffffffffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 1);
         exp = UINT64_C(0x00006a237fffde4b);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2452() {

{
   {
      int64x2_t arg1;
      int32x4_t arg2;
      int32x2_t arg3;
      int64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"qdmla_lane\", fnname = \"vqdmlal_high_lane_s32\", rettype = \"int64x2_t\", argtypes = \"[int64x2_t,int32x4_t,int32x2_t,__constrange(0,1) int]\", vals = [VectorVal [IntegerVal (-9223090562934669312),IntegerVal (-140733193420801)],VectorVal [IntegerVal (-2147450880),IntegerVal (-42380),IntegerVal (-2147450881),IntegerVal (-1563000833)],VectorVal [IntegerVal 665976831,IntegerVal 65535],IndexVal 1], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s64(vcreate_s64(UINT64_C(0x8000ffffc1058000)),
                          vcreate_s64(UINT64_C(0xffff8000ffff7fff)));
      arg2 = vcombine_s32(vcreate_s32(UINT64_C(0xffff5a7480008000)),
                          vcreate_s32(UINT64_C(0xa2d67fff80007fff)));
      arg3 = vcreate_s32(UINT64_C(0x0000ffff27b1ffff));
      clear_neon_saturated();
      //  Expect: "result" = fffec5aeba50800180000001c1028002
      result = vqdmlal_high_lane_s32(arg1, arg2, arg3, 1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 0);
         exp = UINT64_C(0x80000001c1028002);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 1);
         exp = UINT64_C(0xfffec5aeba508001);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2453() {

{
   {
      int64x2_t arg1;
      int32x4_t arg2;
      int32x4_t arg3;
      int64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"qdmla_lane\", fnname = \"vqdmlal_high_laneq_s32\", rettype = \"int64x2_t\", argtypes = \"[int64x2_t,int32x4_t,int32x4_t,__constrange(0,3) int]\", vals = [VectorVal [IntegerVal (-9223244467736210761),IntegerVal 9223372032559854517],VectorVal [IntegerVal (-1978204161),IntegerVal (-2147450880),IntegerVal (-2147450881),IntegerVal 2147418112],VectorVal [IntegerVal (-2147442399),IntegerVal 2147450880,IntegerVal (-2147450881),IntegerVal 0],IndexVal 2], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s64(vcreate_s64(UINT64_C(0x80007405ffff12b7)),
                          vcreate_s64(UINT64_C(0x7fffffff0000b3b5)));
      arg2 = vcombine_s32(vcreate_s32(UINT64_C(0x800080008a16ffff)),
                          vcreate_s32(UINT64_C(0x7fff000080007fff)));
      arg3 = vcombine_s32(vcreate_s32(UINT64_C(0x7fff80008000a121)),
                          vcreate_s32(UINT64_C(0x0000000080007fff)));
      clear_neon_saturated();
      //  Expect: "result" = 00017ffd0002b3b5ffff74087ffd12b9
      result = vqdmlal_high_laneq_s32(arg1, arg2, arg3, 2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 0);
         exp = UINT64_C(0xffff74087ffd12b9);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 1);
         exp = UINT64_C(0x00017ffd0002b3b5);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2454() {

{
   {
      int32_t arg1;
      int16_t arg2;
      int16x4_t arg3;
      int32_t result;
      char* str1 = "ReproInfo2 {semantics = \"qdmla_lane\", fnname = \"vqdmlalh_lane_s16\", rettype = \"int32_t\", argtypes = \"[int32_t,int16_t,int16x4_t,__constrange(0,3) int]\", vals = [IntegerVal 1934196736,IntegerVal (-1),VectorVal [IntegerVal 32767,IntegerVal 32767,IntegerVal (-32768),IntegerVal 0],IndexVal 2], start_saturated = False}";
      int reported = 0;
      int32_t got;
      int32_t exp;
      arg1 = 1934196736;
      arg2 = -1;
      arg3 = vcreate_s16(UINT64_C(0x000080007fff7fff));
      clear_neon_saturated();
      //  Expect: "result" = 734a8000
      result = vqdmlalh_lane_s16(arg1, arg2, arg3, 2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = 1934262272;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIi32 " Got: %" PRIi32 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2455() {

{
   {
      int32_t arg1;
      int16_t arg2;
      int16x8_t arg3;
      int32_t result;
      char* str1 = "ReproInfo2 {semantics = \"qdmla_lane\", fnname = \"vqdmlalh_laneq_s16\", rettype = \"int32_t\", argtypes = \"[int32_t,int16_t,int16x8_t,__constrange(0,7) int]\", vals = [IntegerVal 2147483647,IntegerVal 32767,VectorVal [IntegerVal (-32768),IntegerVal 32767,IntegerVal 32767,IntegerVal (-32768),IntegerVal (-1),IntegerVal (-3359),IntegerVal (-1),IntegerVal 31989],IndexVal 1], start_saturated = False}";
      int reported = 0;
      int32_t got;
      int32_t exp;
      arg1 = 2147483647;
      arg2 = 32767;
      arg3 = vcombine_s16(vcreate_s16(UINT64_C(0x80007fff7fff8000)),
                          vcreate_s16(UINT64_C(0x7cf5fffff2e1ffff)));
      clear_neon_saturated();
      //  Expect: "result" = 7fffffff
      result = vqdmlalh_laneq_s16(arg1, arg2, arg3, 1);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      got = result;
      exp = 2147483647;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIi32 " Got: %" PRIi32 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2456() {

{
   {
      int64_t arg1;
      int32_t arg2;
      int32x2_t arg3;
      int64_t result;
      char* str1 = "ReproInfo2 {semantics = \"qdmla_lane\", fnname = \"vqdmlals_lane_s32\", rettype = \"int64_t\", argtypes = \"[int64_t,int32_t,int32x2_t,__constrange(0,1) int]\", vals = [IntegerVal 140733193440583,IntegerVal (-412614656),VectorVal [IntegerVal 2147450880,IntegerVal 32767],IndexVal 1], start_saturated = False}";
      int reported = 0;
      int64_t got;
      int64_t exp;
      arg1 = INT64_C(140733193440583);
      arg2 = -412614656;
      arg3 = vcreate_s32(UINT64_C(0x00007fff7fff8000));
      clear_neon_saturated();
      //  Expect: "result" = 000067673130cd47
      result = vqdmlals_lane_s32(arg1, arg2, arg3, 1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = INT64_C(113692904574279);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIi64 " Got: %" PRIi64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2457() {

{
   {
      int64_t arg1;
      int32_t arg2;
      int32x4_t arg3;
      int64_t result;
      char* str1 = "ReproInfo2 {semantics = \"qdmla_lane\", fnname = \"vqdmlals_laneq_s32\", rettype = \"int64_t\", argtypes = \"[int64_t,int32_t,int32x4_t,__constrange(0,3) int]\", vals = [IntegerVal (-9223231295071464200),IntegerVal (-32769),VectorVal [IntegerVal (-65536),IntegerVal 2147418112,IntegerVal 32768,IntegerVal 32768],IndexVal 0], start_saturated = False}";
      int reported = 0;
      int64_t got;
      int64_t exp;
      arg1 = INT64_C(-9223231295071464200);
      arg2 = -32769;
      arg3 = vcombine_s32(vcreate_s32(UINT64_C(0x7fff0000ffff0000)),
                          vcreate_s32(UINT64_C(0x0000800000008000)));
      clear_neon_saturated();
      //  Expect: "result" = 800080020001d4f8
      result = vqdmlals_laneq_s32(arg1, arg2, arg3, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = INT64_C(-9223231290776365832);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIi64 " Got: %" PRIi64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2458() {

{
   {
      int16x4_t arg1;
      int16x4_t arg2;
      int16x4_t arg3;
      int16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"mls_lane\", fnname = \"vmls_lane_s16\", rettype = \"int16x4_t\", argtypes = \"[int16x4_t,int16x4_t,int16x4_t,__constrange(0,3) int]\", vals = [VectorVal [IntegerVal 32767,IntegerVal 0,IntegerVal 3406,IntegerVal 15036],VectorVal [IntegerVal (-32768),IntegerVal 32767,IntegerVal 0,IntegerVal (-32768)],VectorVal [IntegerVal 21652,IntegerVal 32767,IntegerVal (-32768),IntegerVal (-1)],IndexVal 2], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s16(UINT64_C(0x3abc0d4e00007fff));
      arg2 = vcreate_s16(UINT64_C(0x800000007fff8000));
      arg3 = vcreate_s16(UINT64_C(0xffff80007fff5494));
      clear_neon_saturated();
      //  Expect: "result" = 3abc0d4e80007fff
      result = vmls_lane_s16(arg1, arg2, arg3, 2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s16(result), 0);
      exp = UINT64_C(0x3abc0d4e80007fff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2459() {

{
   {
      int16x4_t arg1;
      int16x4_t arg2;
      int16x8_t arg3;
      int16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"mls_lane\", fnname = \"vmls_laneq_s16\", rettype = \"int16x4_t\", argtypes = \"[int16x4_t,int16x4_t,int16x8_t,__constrange(0,7) int]\", vals = [VectorVal [IntegerVal 0,IntegerVal 0,IntegerVal 0,IntegerVal (-1)],VectorVal [IntegerVal 32767,IntegerVal 27337,IntegerVal 32767,IntegerVal (-32768)],VectorVal [IntegerVal (-1),IntegerVal 1903,IntegerVal 32767,IntegerVal (-1),IntegerVal 29908,IntegerVal (-1),IntegerVal 0,IntegerVal 0],IndexVal 2], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s16(UINT64_C(0xffff000000000000));
      arg2 = vcreate_s16(UINT64_C(0x80007fff6ac97fff));
      arg3 = vcombine_s16(vcreate_s16(UINT64_C(0xffff7fff076fffff)),
                          vcreate_s16(UINT64_C(0x00000000ffff74d4)));
      clear_neon_saturated();
      //  Expect: "result" = 7fffffffeac9ffff
      result = vmls_laneq_s16(arg1, arg2, arg3, 2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s16(result), 0);
      exp = UINT64_C(0x7fffffffeac9ffff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2460() {

{
   {
      int32x2_t arg1;
      int32x2_t arg2;
      int32x2_t arg3;
      int32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"mls_lane\", fnname = \"vmls_lane_s32\", rettype = \"int32x2_t\", argtypes = \"[int32x2_t,int32x2_t,int32x2_t,__constrange(0,1) int]\", vals = [VectorVal [IntegerVal 0,IntegerVal 170754048],VectorVal [IntegerVal 420446207,IntegerVal 65535],VectorVal [IntegerVal 2013757440,IntegerVal 2147418112],IndexVal 0], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s32(UINT64_C(0x0a2d800000000000));
      arg2 = vcreate_s32(UINT64_C(0x0000ffff190f7fff));
      arg3 = vcreate_s32(UINT64_C(0x7fff000078078000));
      clear_neon_saturated();
      //  Expect: "result" = 0235000038078000
      result = vmls_lane_s32(arg1, arg2, arg3, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s32(result), 0);
      exp = UINT64_C(0x0235000038078000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2461() {

{
   {
      int32x2_t arg1;
      int32x2_t arg2;
      int32x4_t arg3;
      int32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"mls_lane\", fnname = \"vmls_laneq_s32\", rettype = \"int32x2_t\", argtypes = \"[int32x2_t,int32x2_t,int32x4_t,__constrange(0,3) int]\", vals = [VectorVal [IntegerVal 65535,IntegerVal 0],VectorVal [IntegerVal (-633798657),IntegerVal 0],VectorVal [IntegerVal 2147450880,IntegerVal 2147418112,IntegerVal (-1545797632),IntegerVal 2147483647],IndexVal 0], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s32(UINT64_C(0x000000000000ffff));
      arg2 = vcreate_s32(UINT64_C(0x00000000da38ffff));
      arg3 = vcombine_s32(vcreate_s32(UINT64_C(0x7fff00007fff8000)),
                          vcreate_s32(UINT64_C(0x7fffffffa3dd0000)));
      clear_neon_saturated();
      //  Expect: "result" = 0000000000007fff
      result = vmls_laneq_s32(arg1, arg2, arg3, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s32(result), 0);
      exp = UINT64_C(0x0000000000007fff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2462() {

{
   {
      uint16x4_t arg1;
      uint16x4_t arg2;
      uint16x4_t arg3;
      uint16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"mls_lane\", fnname = \"vmls_lane_u16\", rettype = \"uint16x4_t\", argtypes = \"[uint16x4_t,uint16x4_t,uint16x4_t,__constrange(0,3) int]\", vals = [VectorVal [IntegerVal 32767,IntegerVal 32768,IntegerVal 32768,IntegerVal 16615],VectorVal [IntegerVal 65535,IntegerVal 32768,IntegerVal 7436,IntegerVal 0],VectorVal [IntegerVal 32768,IntegerVal 32768,IntegerVal 3347,IntegerVal 65535],IndexVal 3], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u16(UINT64_C(0x40e7800080007fff));
      arg2 = vcreate_u16(UINT64_C(0x00001d0c8000ffff));
      arg3 = vcreate_u16(UINT64_C(0xffff0d1380008000));
      clear_neon_saturated();
      //  Expect: "result" = 40e79d0c00007ffe
      result = vmls_lane_u16(arg1, arg2, arg3, 3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u16(result), 0);
      exp = UINT64_C(0x40e79d0c00007ffe);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2463() {

{
   {
      uint16x4_t arg1;
      uint16x4_t arg2;
      uint16x8_t arg3;
      uint16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"mls_lane\", fnname = \"vmls_laneq_u16\", rettype = \"uint16x4_t\", argtypes = \"[uint16x4_t,uint16x4_t,uint16x8_t,__constrange(0,7) int]\", vals = [VectorVal [IntegerVal 57014,IntegerVal 65535,IntegerVal 0,IntegerVal 40863],VectorVal [IntegerVal 32767,IntegerVal 65535,IntegerVal 32768,IntegerVal 0],VectorVal [IntegerVal 0,IntegerVal 32767,IntegerVal 0,IntegerVal 32768,IntegerVal 32767,IntegerVal 32768,IntegerVal 32768,IntegerVal 32767],IndexVal 7], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u16(UINT64_C(0x9f9f0000ffffdeb6));
      arg2 = vcreate_u16(UINT64_C(0x00008000ffff7fff));
      arg3 = vcombine_u16(vcreate_u16(UINT64_C(0x800000007fff0000)),
                          vcreate_u16(UINT64_C(0x7fff800080007fff)));
      clear_neon_saturated();
      //  Expect: "result" = 9f9f80007ffedeb5
      result = vmls_laneq_u16(arg1, arg2, arg3, 7);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u16(result), 0);
      exp = UINT64_C(0x9f9f80007ffedeb5);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2464() {

{
   {
      uint32x2_t arg1;
      uint32x2_t arg2;
      uint32x2_t arg3;
      uint32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"mls_lane\", fnname = \"vmls_lane_u32\", rettype = \"uint32x2_t\", argtypes = \"[uint32x2_t,uint32x2_t,uint32x2_t,__constrange(0,1) int]\", vals = [VectorVal [IntegerVal 2147516415,IntegerVal 0],VectorVal [IntegerVal 414744575,IntegerVal 0],VectorVal [IntegerVal 32767,IntegerVal 2147516415],IndexVal 1], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u32(UINT64_C(0x0000000080007fff));
      arg2 = vcreate_u32(UINT64_C(0x0000000018b87fff));
      arg3 = vcreate_u32(UINT64_C(0x80007fff00007fff));
      clear_neon_saturated();
      //  Expect: "result" = 00000000d8b97ffe
      result = vmls_lane_u32(arg1, arg2, arg3, 1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u32(result), 0);
      exp = UINT64_C(0x00000000d8b97ffe);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2465() {

{
   {
      uint32x2_t arg1;
      uint32x2_t arg2;
      uint32x4_t arg3;
      uint32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"mls_lane\", fnname = \"vmls_laneq_u32\", rettype = \"uint32x2_t\", argtypes = \"[uint32x2_t,uint32x2_t,uint32x4_t,__constrange(0,3) int]\", vals = [VectorVal [IntegerVal 2147450880,IntegerVal 32768],VectorVal [IntegerVal 2147544224,IntegerVal 2147493304],VectorVal [IntegerVal 3992584192,IntegerVal 3794960383,IntegerVal 2147445302,IntegerVal 2147542033],IndexVal 2], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u32(UINT64_C(0x000080007fff8000));
      arg2 = vcreate_u32(UINT64_C(0x800025b88000eca0));
      arg3 = vcombine_u32(vcreate_u32(UINT64_C(0xe2327fffedfa0000)),
                          vcreate_u32(UINT64_C(0x8000e4117fff6a36)));
      clear_neon_saturated();
      //  Expect: "result" = 16125b300a735640
      result = vmls_laneq_u32(arg1, arg2, arg3, 2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u32(result), 0);
      exp = UINT64_C(0x16125b300a735640);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2466() {

{
   {
      int16x8_t arg1;
      int16x8_t arg2;
      int16x4_t arg3;
      int16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"mls_lane\", fnname = \"vmlsq_lane_s16\", rettype = \"int16x8_t\", argtypes = \"[int16x8_t,int16x8_t,int16x4_t,__constrange(0,3) int]\", vals = [VectorVal [IntegerVal (-23396),IntegerVal 0,IntegerVal 0,IntegerVal 32767,IntegerVal 0,IntegerVal 0,IntegerVal 32767,IntegerVal 20403],VectorVal [IntegerVal (-1584),IntegerVal (-1),IntegerVal 32767,IntegerVal (-23274),IntegerVal 0,IntegerVal 32767,IntegerVal 0,IntegerVal 0],VectorVal [IntegerVal (-1),IntegerVal (-14512),IntegerVal (-32768),IntegerVal 32767],IndexVal 3], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s16(vcreate_s16(UINT64_C(0x7fff00000000a49c)),
                          vcreate_s16(UINT64_C(0x4fb37fff00000000)));
      arg2 = vcombine_s16(vcreate_s16(UINT64_C(0xa5167ffffffff9d0)),
                          vcreate_s16(UINT64_C(0x000000007fff0000)));
      arg3 = vcreate_s16(UINT64_C(0x7fff8000c750ffff));
      clear_neon_saturated();
      //  Expect: "result" = 4fb37fffffff00002515ffff7fff9e6c
      result = vmlsq_lane_s16(arg1, arg2, arg3, 3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 0);
         exp = UINT64_C(0x2515ffff7fff9e6c);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 1);
         exp = UINT64_C(0x4fb37fffffff0000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2467() {

{
   {
      int16x8_t arg1;
      int16x8_t arg2;
      int16x8_t arg3;
      int16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"mls_lane\", fnname = \"vmlsq_laneq_s16\", rettype = \"int16x8_t\", argtypes = \"[int16x8_t,int16x8_t,int16x8_t,__constrange(0,7) int]\", vals = [VectorVal [IntegerVal (-32768),IntegerVal (-1),IntegerVal 0,IntegerVal (-1),IntegerVal 24547,IntegerVal 32767,IntegerVal (-575),IntegerVal (-32768)],VectorVal [IntegerVal 32767,IntegerVal 32767,IntegerVal (-1),IntegerVal 0,IntegerVal 32767,IntegerVal 32767,IntegerVal 18642,IntegerVal (-1)],VectorVal [IntegerVal 0,IntegerVal 0,IntegerVal (-1),IntegerVal 32767,IntegerVal (-17992),IntegerVal 32767,IntegerVal 0,IntegerVal (-1)],IndexVal 2], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s16(vcreate_s16(UINT64_C(0xffff0000ffff8000)),
                          vcreate_s16(UINT64_C(0x8000fdc17fff5fe3)));
      arg2 = vcombine_s16(vcreate_s16(UINT64_C(0x0000ffff7fff7fff)),
                          vcreate_s16(UINT64_C(0xffff48d27fff7fff)));
      arg3 = vcombine_s16(vcreate_s16(UINT64_C(0x7fffffff00000000)),
                          vcreate_s16(UINT64_C(0xffff00007fffb9b8)));
      clear_neon_saturated();
      //  Expect: "result" = 7fff4693fffedfe2ffffffff7ffeffff
      result = vmlsq_laneq_s16(arg1, arg2, arg3, 2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 0);
         exp = UINT64_C(0xffffffff7ffeffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 1);
         exp = UINT64_C(0x7fff4693fffedfe2);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2468() {

{
   {
      int32x4_t arg1;
      int32x4_t arg2;
      int32x2_t arg3;
      int32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"mls_lane\", fnname = \"vmlsq_lane_s32\", rettype = \"int32x4_t\", argtypes = \"[int32x4_t,int32x4_t,int32x2_t,__constrange(0,1) int]\", vals = [VectorVal [IntegerVal (-1820118396),IntegerVal 65535,IntegerVal 64084,IntegerVal 2147483647],VectorVal [IntegerVal (-2147483648),IntegerVal (-2147483648),IntegerVal 2147450880,IntegerVal (-2147450881)],VectorVal [IntegerVal 2147483647,IntegerVal 1363312640],IndexVal 0], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s32(vcreate_s32(UINT64_C(0x0000ffff93833284)),
                          vcreate_s32(UINT64_C(0x7fffffff0000fa54)));
      arg2 = vcombine_s32(vcreate_s32(UINT64_C(0x8000000080000000)),
                          vcreate_s32(UINT64_C(0x80007fff7fff8000)));
      arg3 = vcreate_s32(UINT64_C(0x514280007fffffff));
      clear_neon_saturated();
      //  Expect: "result" = 80007ffe80007a548000ffff13833284
      result = vmlsq_lane_s32(arg1, arg2, arg3, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 0);
         exp = UINT64_C(0x8000ffff13833284);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 1);
         exp = UINT64_C(0x80007ffe80007a54);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2469() {

{
   {
      int32x4_t arg1;
      int32x4_t arg2;
      int32x4_t arg3;
      int32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"mls_lane\", fnname = \"vmlsq_laneq_s32\", rettype = \"int32x4_t\", argtypes = \"[int32x4_t,int32x4_t,int32x4_t,__constrange(0,3) int]\", vals = [VectorVal [IntegerVal (-65536),IntegerVal 2147455499,IntegerVal (-344588288),IntegerVal (-32769)],VectorVal [IntegerVal (-32768),IntegerVal (-2147450881),IntegerVal 65535,IntegerVal (-2147450880)],VectorVal [IntegerVal 2147476534,IntegerVal (-53903361),IntegerVal (-59336),IntegerVal (-2147450881)],IndexVal 0], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s32(vcreate_s32(UINT64_C(0x7fff920bffff0000)),
                          vcreate_s32(UINT64_C(0xffff7fffeb760000)));
      arg2 = vcombine_s32(vcreate_s32(UINT64_C(0x80007fffffff8000)),
                          vcreate_s32(UINT64_C(0x800080000000ffff)));
      arg3 = vcombine_s32(vcreate_s32(UINT64_C(0xfcc97fff7fffe436)),
                          vcreate_s32(UINT64_C(0x80007fffffff1838)));
      clear_neon_saturated();
      //  Expect: "result" = 0de47fff873fe4360de47641f21a0000
      result = vmlsq_laneq_s32(arg1, arg2, arg3, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 0);
         exp = UINT64_C(0x0de47641f21a0000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 1);
         exp = UINT64_C(0x0de47fff873fe436);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2470() {

{
   {
      uint16x8_t arg1;
      uint16x8_t arg2;
      uint16x4_t arg3;
      uint16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"mls_lane\", fnname = \"vmlsq_lane_u16\", rettype = \"uint16x8_t\", argtypes = \"[uint16x8_t,uint16x8_t,uint16x4_t,__constrange(0,3) int]\", vals = [VectorVal [IntegerVal 7163,IntegerVal 65535,IntegerVal 65535,IntegerVal 65535,IntegerVal 32768,IntegerVal 0,IntegerVal 65535,IntegerVal 35182],VectorVal [IntegerVal 32768,IntegerVal 65535,IntegerVal 0,IntegerVal 65535,IntegerVal 40790,IntegerVal 32767,IntegerVal 65535,IntegerVal 45411],VectorVal [IntegerVal 65535,IntegerVal 32767,IntegerVal 9691,IntegerVal 0],IndexVal 2], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u16(vcreate_u16(UINT64_C(0xffffffffffff1bfb)),
                          vcreate_u16(UINT64_C(0x896effff00008000)));
      arg2 = vcombine_u16(vcreate_u16(UINT64_C(0xffff0000ffff8000)),
                          vcreate_u16(UINT64_C(0xb163ffff7fff9f56)));
      arg3 = vcreate_u16(UINT64_C(0x000025db7fffffff));
      clear_neon_saturated();
      //  Expect: "result" = 7abd25daa5dbc36e25daffff25da9bfb
      result = vmlsq_lane_u16(arg1, arg2, arg3, 2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 0);
         exp = UINT64_C(0x25daffff25da9bfb);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 1);
         exp = UINT64_C(0x7abd25daa5dbc36e);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2471() {

{
   {
      uint16x8_t arg1;
      uint16x8_t arg2;
      uint16x8_t arg3;
      uint16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"mls_lane\", fnname = \"vmlsq_laneq_u16\", rettype = \"uint16x8_t\", argtypes = \"[uint16x8_t,uint16x8_t,uint16x8_t,__constrange(0,7) int]\", vals = [VectorVal [IntegerVal 32767,IntegerVal 0,IntegerVal 32767,IntegerVal 45644,IntegerVal 32768,IntegerVal 0,IntegerVal 32767,IntegerVal 27875],VectorVal [IntegerVal 32767,IntegerVal 0,IntegerVal 65535,IntegerVal 65535,IntegerVal 24211,IntegerVal 32768,IntegerVal 32767,IntegerVal 0],VectorVal [IntegerVal 0,IntegerVal 32768,IntegerVal 65535,IntegerVal 32767,IntegerVal 46564,IntegerVal 32767,IntegerVal 32768,IntegerVal 0],IndexVal 4], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u16(vcreate_u16(UINT64_C(0xb24c7fff00007fff)),
                          vcreate_u16(UINT64_C(0x6ce37fff00008000)));
      arg2 = vcombine_u16(vcreate_u16(UINT64_C(0xffffffff00007fff)),
                          vcreate_u16(UINT64_C(0x00007fff80005e93)));
      arg3 = vcombine_u16(vcreate_u16(UINT64_C(0x7fffffff80000000)),
                          vcreate_u16(UINT64_C(0x000080007fffb5e4)));
      clear_neon_saturated();
      //  Expect: "result" = 6ce335e300005614683035e3000035e3
      result = vmlsq_laneq_u16(arg1, arg2, arg3, 4);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 0);
         exp = UINT64_C(0x683035e3000035e3);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 1);
         exp = UINT64_C(0x6ce335e300005614);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2472() {

{
   {
      uint32x4_t arg1;
      uint32x4_t arg2;
      uint32x2_t arg3;
      uint32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"mls_lane\", fnname = \"vmlsq_lane_u32\", rettype = \"uint32x4_t\", argtypes = \"[uint32x4_t,uint32x4_t,uint32x2_t,__constrange(0,1) int]\", vals = [VectorVal [IntegerVal 59251,IntegerVal 2147450879,IntegerVal 65535,IntegerVal 2147516415],VectorVal [IntegerVal 4294967295,IntegerVal 2147418112,IntegerVal 2147483648,IntegerVal 2147450879],VectorVal [IntegerVal 2147450880,IntegerVal 2147483647],IndexVal 1], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u32(vcreate_u32(UINT64_C(0x7fff7fff0000e773)),
                          vcreate_u32(UINT64_C(0x80007fff0000ffff)));
      arg2 = vcombine_u32(vcreate_u32(UINT64_C(0x7fff0000ffffffff)),
                          vcreate_u32(UINT64_C(0x7fff7fff80000000)));
      arg3 = vcreate_u32(UINT64_C(0x7fffffff7fff8000));
      clear_neon_saturated();
      //  Expect: "result" = 7ffffffe8000fffffffe7fff8000e772
      result = vmlsq_lane_u32(arg1, arg2, arg3, 1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 0);
         exp = UINT64_C(0xfffe7fff8000e772);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 1);
         exp = UINT64_C(0x7ffffffe8000ffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2473() {

{
   {
      uint32x4_t arg1;
      uint32x4_t arg2;
      uint32x4_t arg3;
      uint32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"mls_lane\", fnname = \"vmlsq_laneq_u32\", rettype = \"uint32x4_t\", argtypes = \"[uint32x4_t,uint32x4_t,uint32x4_t,__constrange(0,3) int]\", vals = [VectorVal [IntegerVal 32768,IntegerVal 2147450879,IntegerVal 3839721471,IntegerVal 2658369535],VectorVal [IntegerVal 2564390911,IntegerVal 0,IntegerVal 4294934528,IntegerVal 0],VectorVal [IntegerVal 700088319,IntegerVal 2147516416,IntegerVal 4294934527,IntegerVal 101122047],IndexVal 2], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u32(vcreate_u32(UINT64_C(0x7fff7fff00008000)),
                          vcreate_u32(UINT64_C(0x9e737fffe4dd7fff)));
      arg2 = vcombine_u32(vcreate_u32(UINT64_C(0x0000000098d97fff)),
                          vcreate_u32(UINT64_C(0x00000000ffff8000)));
      arg3 = vcombine_u32(vcreate_u32(UINT64_C(0x8000800029ba7fff)),
                          vcreate_u32(UINT64_C(0x0606ffffffff7fff)));
      clear_neon_saturated();
      //  Expect: "result" = 9e737fffa4dcffff7fff7fff58d97fff
      result = vmlsq_laneq_u32(arg1, arg2, arg3, 2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 0);
         exp = UINT64_C(0x7fff7fff58d97fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 1);
         exp = UINT64_C(0x9e737fffa4dcffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2474() {

{
   {
      int32x4_t arg1;
      int16x4_t arg2;
      int16x4_t arg3;
      int32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"mls_lane\", fnname = \"vmlsl_lane_s16\", rettype = \"int32x4_t\", argtypes = \"[int32x4_t,int16x4_t,int16x4_t,__constrange(0,3) int]\", vals = [VectorVal [IntegerVal (-1658631695),IntegerVal 32768,IntegerVal 1343717375,IntegerVal 2147450880],VectorVal [IntegerVal (-24874),IntegerVal 32767,IntegerVal (-1),IntegerVal (-32768)],VectorVal [IntegerVal 32767,IntegerVal 32767,IntegerVal (-32768),IntegerVal 20288],IndexVal 0], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s32(vcreate_s32(UINT64_C(0x000080009d2349f1)),
                          vcreate_s32(UINT64_C(0x7fff800050177fff)));
      arg2 = vcreate_s16(UINT64_C(0x8000ffff7fff9ed6));
      arg3 = vcreate_s16(UINT64_C(0x4f4080007fff7fff));
      clear_neon_saturated();
      //  Expect: "result" = bfff00005017fffec0017fffcdb7e8c7
      result = vmlsl_lane_s16(arg1, arg2, arg3, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 0);
         exp = UINT64_C(0xc0017fffcdb7e8c7);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 1);
         exp = UINT64_C(0xbfff00005017fffe);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2475() {

{
   {
      int32x4_t arg1;
      int16x4_t arg2;
      int16x8_t arg3;
      int32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"mls_lane\", fnname = \"vmlsl_laneq_s16\", rettype = \"int32x4_t\", argtypes = \"[int32x4_t,int16x4_t,int16x8_t,__constrange(0,7) int]\", vals = [VectorVal [IntegerVal (-65536),IntegerVal 2147418112,IntegerVal (-65536),IntegerVal (-32768)],VectorVal [IntegerVal 0,IntegerVal 32767,IntegerVal (-2977),IntegerVal (-8791)],VectorVal [IntegerVal (-1),IntegerVal 32767,IntegerVal (-1),IntegerVal (-4203),IntegerVal 0,IntegerVal (-1),IntegerVal 32767,IntegerVal 20917],IndexVal 1], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s32(vcreate_s32(UINT64_C(0x7fff0000ffff0000)),
                          vcreate_s32(UINT64_C(0xffff8000ffff0000)));
      arg2 = vcreate_s16(UINT64_C(0xdda9f45f7fff0000));
      arg3 = vcombine_s16(vcreate_s16(UINT64_C(0xef95ffff7fffffff)),
                          vcreate_s16(UINT64_C(0x51b57fffffff0000)));
      clear_neon_saturated();
      //  Expect: "result" = 112adda905cf745f3fffffffffff0000
      result = vmlsl_laneq_s16(arg1, arg2, arg3, 1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 0);
         exp = UINT64_C(0x3fffffffffff0000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 1);
         exp = UINT64_C(0x112adda905cf745f);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2476() {

{
   {
      int32x4_t arg1;
      int16x8_t arg2;
      int16x4_t arg3;
      int32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"mls_lane\", fnname = \"vmlsl_high_lane_s16\", rettype = \"int32x4_t\", argtypes = \"[int32x4_t,int16x8_t,int16x4_t,__constrange(0,3) int]\", vals = [VectorVal [IntegerVal 2147418112,IntegerVal 974422930,IntegerVal 32768,IntegerVal (-32768)],VectorVal [IntegerVal 0,IntegerVal 32767,IntegerVal 32767,IntegerVal 0,IntegerVal (-11804),IntegerVal 32767,IntegerVal (-32768),IntegerVal (-1)],VectorVal [IntegerVal 0,IntegerVal (-1),IntegerVal (-22586),IntegerVal (-1)],IndexVal 3], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s32(vcreate_s32(UINT64_C(0x3a1483927fff0000)),
                          vcreate_s32(UINT64_C(0xffff800000008000)));
      arg2 = vcombine_s16(vcreate_s16(UINT64_C(0x00007fff7fff0000)),
                          vcreate_s16(UINT64_C(0xffff80007fffd1e4)));
      arg3 = vcreate_s16(UINT64_C(0xffffa7c6ffff0000));
      clear_neon_saturated();
      //  Expect: "result" = ffff7fff000000003a1503917ffed1e4
      result = vmlsl_high_lane_s16(arg1, arg2, arg3, 3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 0);
         exp = UINT64_C(0x3a1503917ffed1e4);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 1);
         exp = UINT64_C(0xffff7fff00000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2477() {

{
   {
      int32x4_t arg1;
      int16x8_t arg2;
      int16x8_t arg3;
      int32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"mls_lane\", fnname = \"vmlsl_high_laneq_s16\", rettype = \"int32x4_t\", argtypes = \"[int32x4_t,int16x8_t,int16x8_t,__constrange(0,7) int]\", vals = [VectorVal [IntegerVal (-54055),IntegerVal 2147450880,IntegerVal 32767,IntegerVal 1741783040],VectorVal [IntegerVal (-1),IntegerVal (-32768),IntegerVal (-1),IntegerVal 297,IntegerVal 0,IntegerVal (-32768),IntegerVal 25069,IntegerVal 0],VectorVal [IntegerVal 32767,IntegerVal 0,IntegerVal (-32768),IntegerVal 32767,IntegerVal (-32768),IntegerVal 32767,IntegerVal 11827,IntegerVal 0],IndexVal 6], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s32(vcreate_s32(UINT64_C(0x7fff8000ffff2cd9)),
                          vcreate_s32(UINT64_C(0x67d1800000007fff)));
      arg2 = vcombine_s16(vcreate_s16(UINT64_C(0x0129ffff8000ffff)),
                          vcreate_s16(UINT64_C(0x000061ed80000000)));
      arg3 = vcombine_s16(vcreate_s16(UINT64_C(0x7fff800000007fff)),
                          vcreate_s16(UINT64_C(0x00002e337fff8000)));
      clear_neon_saturated();
      //  Expect: "result" = 67d18000ee5467c897190000ffff2cd9
      result = vmlsl_high_laneq_s16(arg1, arg2, arg3, 6);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 0);
         exp = UINT64_C(0x97190000ffff2cd9);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 1);
         exp = UINT64_C(0x67d18000ee5467c8);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2478() {

{
   {
      int64x2_t arg1;
      int32x2_t arg2;
      int32x2_t arg3;
      int64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"mls_lane\", fnname = \"vmlsl_lane_s32\", rettype = \"int64x2_t\", argtypes = \"[int64x2_t,int32x2_t,int32x2_t,__constrange(0,1) int]\", vals = [VectorVal [IntegerVal 2147483648,IntegerVal (-140739635806208)],VectorVal [IntegerVal (-32768),IntegerVal 2147483647],VectorVal [IntegerVal (-1),IntegerVal 100237311],IndexVal 0], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s64(vcreate_s64(UINT64_C(0x0000000080000000)),
                          vcreate_s64(UINT64_C(0xffff7fff80008000)));
      arg2 = vcreate_s32(UINT64_C(0x7fffffffffff8000));
      arg3 = vcreate_s32(UINT64_C(0x05f97fffffffffff));
      clear_neon_saturated();
      //  Expect: "result" = ffff800000007fff000000007fff8000
      result = vmlsl_lane_s32(arg1, arg2, arg3, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 0);
         exp = UINT64_C(0x000000007fff8000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 1);
         exp = UINT64_C(0xffff800000007fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2479() {

{
   {
      int64x2_t arg1;
      int32x2_t arg2;
      int32x4_t arg3;
      int64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"mls_lane\", fnname = \"vmlsl_laneq_s32\", rettype = \"int64x2_t\", argtypes = \"[int64x2_t,int32x2_t,int32x4_t,__constrange(0,3) int]\", vals = [VectorVal [IntegerVal 104805740417417215,IntegerVal (-4249579264584137860)],VectorVal [IntegerVal (-32768),IntegerVal (-2147483648)],VectorVal [IntegerVal 32767,IntegerVal (-2147418113),IntegerVal 41549823,IntegerVal 1716223999],IndexVal 0], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s64(vcreate_s64(UINT64_C(0x0174584400007fff)),
                          vcreate_s64(UINT64_C(0xc506762c9198c37c)));
      arg2 = vcreate_s32(UINT64_C(0x80000000ffff8000));
      arg3 = vcombine_s32(vcreate_s32(UINT64_C(0x8000ffff00007fff)),
                          vcreate_s32(UINT64_C(0x664b7fff0279ffff)));
      clear_neon_saturated();
      //  Expect: "result" = c506b62c1198c37c017458443fffffff
      result = vmlsl_laneq_s32(arg1, arg2, arg3, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 0);
         exp = UINT64_C(0x017458443fffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 1);
         exp = UINT64_C(0xc506b62c1198c37c);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2480() {

{
   {
      int64x2_t arg1;
      int32x4_t arg2;
      int32x2_t arg3;
      int64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"mls_lane\", fnname = \"vmlsl_high_lane_s32\", rettype = \"int64x2_t\", argtypes = \"[int64x2_t,int32x4_t,int32x2_t,__constrange(0,1) int]\", vals = [VectorVal [IntegerVal 7165930692440727380,IntegerVal 9223098881229682999],VectorVal [IntegerVal (-65536),IntegerVal 2147483647,IntegerVal (-2147450880),IntegerVal 32768],VectorVal [IntegerVal 457932799,IntegerVal 2147418112],IndexVal 1], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s64(vcreate_s64(UINT64_C(0x63727fff7fff9f54)),
                          vcreate_s64(UINT64_C(0x7fff0790ffff7937)));
      arg2 = vcombine_s32(vcreate_s32(UINT64_C(0x7fffffffffff0000)),
                          vcreate_s32(UINT64_C(0x0000800080008000)));
      arg3 = vcreate_s32(UINT64_C(0x7fff00001b4b7fff));
      clear_neon_saturated();
      //  Expect: "result" = 7ffec7917fff7937a371bfffffff9f54
      result = vmlsl_high_lane_s32(arg1, arg2, arg3, 1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 0);
         exp = UINT64_C(0xa371bfffffff9f54);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 1);
         exp = UINT64_C(0x7ffec7917fff7937);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2481() {

{
   {
      int64x2_t arg1;
      int32x4_t arg2;
      int32x4_t arg3;
      int64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"mls_lane\", fnname = \"vmlsl_high_laneq_s32\", rettype = \"int64x2_t\", argtypes = \"[int64x2_t,int32x4_t,int32x4_t,__constrange(0,3) int]\", vals = [VectorVal [IntegerVal (-9223231301513969664),IntegerVal (-65536)],VectorVal [IntegerVal (-2147450880),IntegerVal (-65536),IntegerVal 2147483647,IntegerVal (-2147483648)],VectorVal [IntegerVal (-2147462492),IntegerVal (-32768),IntegerVal 2147483647,IntegerVal (-2147436888)],IndexVal 0], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s64(vcreate_s64(UINT64_C(0x80007fff7fff0000)),
                          vcreate_s64(UINT64_C(0xffffffffffff0000)));
      arg2 = vcombine_s32(vcreate_s32(UINT64_C(0xffff000080008000)),
                          vcreate_s32(UINT64_C(0x800000007fffffff)));
      arg3 = vcombine_s32(vcreate_s32(UINT64_C(0xffff8000800052a4)),
                          vcreate_s32(UINT64_C(0x8000b6a87fffffff)));
      clear_neon_saturated();
      //  Expect: "result" = c0002951ffff0000c00056acffff52a4
      result = vmlsl_high_laneq_s32(arg1, arg2, arg3, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 0);
         exp = UINT64_C(0xc00056acffff52a4);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 1);
         exp = UINT64_C(0xc0002951ffff0000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2482() {

{
   {
      uint32x4_t arg1;
      uint16x4_t arg2;
      uint16x4_t arg3;
      uint32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"mls_lane\", fnname = \"vmlsl_lane_u16\", rettype = \"uint32x4_t\", argtypes = \"[uint32x4_t,uint16x4_t,uint16x4_t,__constrange(0,3) int]\", vals = [VectorVal [IntegerVal 94306304,IntegerVal 2147483648,IntegerVal 65535,IntegerVal 2147516416],VectorVal [IntegerVal 32768,IntegerVal 24266,IntegerVal 32767,IntegerVal 0],VectorVal [IntegerVal 3975,IntegerVal 32767,IntegerVal 65535,IntegerVal 32767],IndexVal 3], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u32(vcreate_u32(UINT64_C(0x80000000059f0000)),
                          vcreate_u32(UINT64_C(0x800080000000ffff)));
      arg2 = vcreate_u16(UINT64_C(0x00007fff5eca8000));
      arg3 = vcreate_u16(UINT64_C(0x7fffffff7fff0f87));
      clear_neon_saturated();
      //  Expect: "result" = 80008000c001fffe509b5ecac59f8000
      result = vmlsl_lane_u16(arg1, arg2, arg3, 3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 0);
         exp = UINT64_C(0x509b5ecac59f8000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 1);
         exp = UINT64_C(0x80008000c001fffe);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2483() {

{
   {
      uint32x4_t arg1;
      uint16x4_t arg2;
      uint16x8_t arg3;
      uint32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"mls_lane\", fnname = \"vmlsl_laneq_u16\", rettype = \"uint32x4_t\", argtypes = \"[uint32x4_t,uint16x4_t,uint16x8_t,__constrange(0,7) int]\", vals = [VectorVal [IntegerVal 2147549183,IntegerVal 2147516415,IntegerVal 0,IntegerVal 2147450880],VectorVal [IntegerVal 32767,IntegerVal 32768,IntegerVal 0,IntegerVal 1089],VectorVal [IntegerVal 32768,IntegerVal 32768,IntegerVal 32767,IntegerVal 32767,IntegerVal 55971,IntegerVal 45549,IntegerVal 32768,IntegerVal 32768],IndexVal 7], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u32(vcreate_u32(UINT64_C(0x80007fff8000ffff)),
                          vcreate_u32(UINT64_C(0x7fff800000000000)));
      arg2 = vcreate_u16(UINT64_C(0x0441000080007fff));
      arg3 = vcombine_u16(vcreate_u16(UINT64_C(0x7fff7fff80008000)),
                          vcreate_u16(UINT64_C(0x80008000b1eddaa3)));
      clear_neon_saturated();
      //  Expect: "result" = 7ddf00000000000040007fff40017fff
      result = vmlsl_laneq_u16(arg1, arg2, arg3, 7);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 0);
         exp = UINT64_C(0x40007fff40017fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 1);
         exp = UINT64_C(0x7ddf000000000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2484() {

{
   {
      uint32x4_t arg1;
      uint16x8_t arg2;
      uint16x4_t arg3;
      uint32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"mls_lane\", fnname = \"vmlsl_high_lane_u16\", rettype = \"uint32x4_t\", argtypes = \"[uint32x4_t,uint16x8_t,uint16x4_t,__constrange(0,3) int]\", vals = [VectorVal [IntegerVal 32767,IntegerVal 4294937731,IntegerVal 2147516416,IntegerVal 2438561791],VectorVal [IntegerVal 65535,IntegerVal 32768,IntegerVal 65535,IntegerVal 0,IntegerVal 32768,IntegerVal 32768,IntegerVal 32767,IntegerVal 65535],VectorVal [IntegerVal 0,IntegerVal 0,IntegerVal 0,IntegerVal 32767],IndexVal 1], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u32(vcreate_u32(UINT64_C(0xffff8c8300007fff)),
                          vcreate_u32(UINT64_C(0x91597fff80008000)));
      arg2 = vcombine_u16(vcreate_u16(UINT64_C(0x0000ffff8000ffff)),
                          vcreate_u16(UINT64_C(0xffff7fff80008000)));
      arg3 = vcreate_u16(UINT64_C(0x7fff000000000000));
      clear_neon_saturated();
      //  Expect: "result" = 91597fff80008000ffff8c8300007fff
      result = vmlsl_high_lane_u16(arg1, arg2, arg3, 1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 0);
         exp = UINT64_C(0xffff8c8300007fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 1);
         exp = UINT64_C(0x91597fff80008000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2485() {

{
   {
      uint32x4_t arg1;
      uint16x8_t arg2;
      uint16x8_t arg3;
      uint32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"mls_lane\", fnname = \"vmlsl_high_laneq_u16\", rettype = \"uint32x4_t\", argtypes = \"[uint32x4_t,uint16x8_t,uint16x8_t,__constrange(0,7) int]\", vals = [VectorVal [IntegerVal 2149220351,IntegerVal 2147516416,IntegerVal 4294934528,IntegerVal 2147516416],VectorVal [IntegerVal 65535,IntegerVal 32767,IntegerVal 65535,IntegerVal 0,IntegerVal 65535,IntegerVal 0,IntegerVal 32768,IntegerVal 42919],VectorVal [IntegerVal 65535,IntegerVal 32767,IntegerVal 32768,IntegerVal 0,IntegerVal 65535,IntegerVal 2833,IntegerVal 0,IntegerVal 0],IndexVal 5], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u32(vcreate_u32(UINT64_C(0x80008000801a7fff)),
                          vcreate_u32(UINT64_C(0x80008000ffff8000)));
      arg2 = vcombine_u16(vcreate_u16(UINT64_C(0x0000ffff7fffffff)),
                          vcreate_u16(UINT64_C(0xa7a780000000ffff)));
      arg3 = vcombine_u16(vcreate_u16(UINT64_C(0x000080007fffffff)),
                          vcreate_u16(UINT64_C(0x000000000b11ffff)));
      clear_neon_saturated();
      //  Expect: "result" = 78c130e9fa7700008000800075098b10
      result = vmlsl_high_laneq_u16(arg1, arg2, arg3, 5);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 0);
         exp = UINT64_C(0x8000800075098b10);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 1);
         exp = UINT64_C(0x78c130e9fa770000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2486() {

{
   {
      uint64x2_t arg1;
      uint32x2_t arg2;
      uint32x2_t arg3;
      uint64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"mls_lane\", fnname = \"vmlsl_lane_u32\", rettype = \"uint64x2_t\", argtypes = \"[uint64x2_t,uint32x2_t,uint32x2_t,__constrange(0,1) int]\", vals = [VectorVal [IntegerVal 18446462600880355875,IntegerVal 8481823634074107904],VectorVal [IntegerVal 2147516416,IntegerVal 4294934527],VectorVal [IntegerVal 0,IntegerVal 4294963812],IndexVal 1], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u64(vcreate_u64(UINT64_C(0xffff000080007a23)),
                          vcreate_u64(UINT64_C(0x75b57da814800000)));
      arg2 = vcreate_u32(UINT64_C(0xffff7fff80008000));
      arg3 = vcreate_u32(UINT64_C(0xfffff26400000000));
      clear_neon_saturated();
      //  Expect: "result" = 75b60b450db1f2647ffe86ce86ce7a23
      result = vmlsl_lane_u32(arg1, arg2, arg3, 1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 0);
         exp = UINT64_C(0x7ffe86ce86ce7a23);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 1);
         exp = UINT64_C(0x75b60b450db1f264);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2487() {

{
   {
      uint64x2_t arg1;
      uint32x2_t arg2;
      uint32x4_t arg3;
      uint64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"mls_lane\", fnname = \"vmlsl_laneq_u32\", rettype = \"uint64x2_t\", argtypes = \"[uint64x2_t,uint32x2_t,uint32x4_t,__constrange(0,3) int]\", vals = [VectorVal [IntegerVal 9223512771637655724,IntegerVal 9223372032559874047],VectorVal [IntegerVal 2147450879,IntegerVal 2147418112],VectorVal [IntegerVal 2147483648,IntegerVal 32768,IntegerVal 4294934527,IntegerVal 2147516415],IndexVal 1], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u64(vcreate_u64(UINT64_C(0x80007fff5ebdb8ac)),
                          vcreate_u64(UINT64_C(0x7fffffff0000ffff)));
      arg2 = vcreate_u32(UINT64_C(0x7fff00007fff7fff));
      arg3 = vcombine_u32(vcreate_u32(UINT64_C(0x0000800080000000)),
                          vcreate_u32(UINT64_C(0x80007fffffff7fff)));
      clear_neon_saturated();
      //  Expect: "result" = 7fffbfff8000ffff80003fff9ebe38ac
      result = vmlsl_laneq_u32(arg1, arg2, arg3, 1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 0);
         exp = UINT64_C(0x80003fff9ebe38ac);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 1);
         exp = UINT64_C(0x7fffbfff8000ffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2488() {

{
   {
      uint64x2_t arg1;
      uint32x4_t arg2;
      uint32x2_t arg3;
      uint64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"mls_lane\", fnname = \"vmlsl_high_lane_u32\", rettype = \"uint64x2_t\", argtypes = \"[uint64x2_t,uint32x4_t,uint32x2_t,__constrange(0,1) int]\", vals = [VectorVal [IntegerVal 9223512776490549248,IntegerVal 194957155500031],VectorVal [IntegerVal 4132470783,IntegerVal 3742800183,IntegerVal 65535,IntegerVal 2147418112],VectorVal [IntegerVal 2147450880,IntegerVal 2147426184],IndexVal 1], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u64(vcreate_u64(UINT64_C(0x800080007fff0000)),
                          vcreate_u64(UINT64_C(0x0000b14fffffffff)));
      arg2 = vcombine_u32(vcreate_u32(UINT64_C(0xdf169937f6507fff)),
                          vcreate_u32(UINT64_C(0x7fff00000000ffff)));
      arg3 = vcreate_u32(UINT64_C(0x7fff1f887fff8000));
      clear_neon_saturated();
      //  Expect: "result" = c001a18b1f87ffff80000001e0761f88
      result = vmlsl_high_lane_u32(arg1, arg2, arg3, 1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 0);
         exp = UINT64_C(0x80000001e0761f88);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 1);
         exp = UINT64_C(0xc001a18b1f87ffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2489() {

{
   {
      uint64x2_t arg1;
      uint32x4_t arg2;
      uint32x4_t arg3;
      uint64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"mls_lane\", fnname = \"vmlsl_high_laneq_u32\", rettype = \"uint64x2_t\", argtypes = \"[uint64x2_t,uint32x4_t,uint32x4_t,__constrange(0,3) int]\", vals = [VectorVal [IntegerVal 16302326965786902528,IntegerVal 18446495558311903231],VectorVal [IntegerVal 2147483648,IntegerVal 65535,IntegerVal 39785,IntegerVal 2147516415],VectorVal [IntegerVal 2147549183,IntegerVal 3319627775,IntegerVal 2147418112,IntegerVal 2147483647],IndexVal 3], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u64(vcreate_u64(UINT64_C(0xe23d800080000000)),
                          vcreate_u64(UINT64_C(0xffff1dfa00007fff)));
      arg2 = vcombine_u32(vcreate_u32(UINT64_C(0x0000ffff80000000)),
                          vcreate_u32(UINT64_C(0x80007fff00009b69)));
      arg3 = vcombine_u32(vcreate_u32(UINT64_C(0xc5dd7fff8000ffff)),
                          vcreate_u32(UINT64_C(0x7fffffff7fff0000)));
      clear_neon_saturated();
      //  Expect: "result" = bffeddfb0000fffee23d324c00009b69
      result = vmlsl_high_laneq_u32(arg1, arg2, arg3, 3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 0);
         exp = UINT64_C(0xe23d324c00009b69);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 1);
         exp = UINT64_C(0xbffeddfb0000fffe);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2490() {

{
   {
      int32x4_t arg1;
      int16x4_t arg2;
      int16x4_t arg3;
      int32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"qdmls_lane\", fnname = \"vqdmlsl_lane_s16\", rettype = \"int32x4_t\", argtypes = \"[int32x4_t,int16x4_t,int16x4_t,__constrange(0,3) int]\", vals = [VectorVal [IntegerVal (-2147483648),IntegerVal (-65536),IntegerVal 856588287,IntegerVal 761167872],VectorVal [IntegerVal (-1),IntegerVal (-32768),IntegerVal 0,IntegerVal (-32768)],VectorVal [IntegerVal (-16989),IntegerVal (-18784),IntegerVal (-1),IntegerVal 27387],IndexVal 3], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s32(vcreate_s32(UINT64_C(0xffff000080000000)),
                          vcreate_s32(UINT64_C(0x2d5e8000330e7fff)));
      arg2 = vcreate_s16(UINT64_C(0x800000008000ffff));
      arg3 = vcreate_s16(UINT64_C(0x6afbffffb6a0bda3));
      clear_neon_saturated();
      //  Expect: "result" = 7fffffff330e7fff6afa00008000d5f6
      result = vqdmlsl_lane_s16(arg1, arg2, arg3, 3);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 0);
         exp = UINT64_C(0x6afa00008000d5f6);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 1);
         exp = UINT64_C(0x7fffffff330e7fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2491() {

{
   {
      int32x4_t arg1;
      int16x4_t arg2;
      int16x8_t arg3;
      int32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"qdmls_lane\", fnname = \"vqdmlsl_laneq_s16\", rettype = \"int32x4_t\", argtypes = \"[int32x4_t,int16x4_t,int16x8_t,__constrange(0,7) int]\", vals = [VectorVal [IntegerVal (-1488125952),IntegerVal (-44311),IntegerVal 49019,IntegerVal (-2147450880)],VectorVal [IntegerVal (-1),IntegerVal (-32768),IntegerVal 0,IntegerVal (-32768)],VectorVal [IntegerVal (-1),IntegerVal (-32768),IntegerVal 32767,IntegerVal (-10964),IntegerVal (-31181),IntegerVal 32767,IntegerVal (-8319),IntegerVal (-1)],IndexVal 2], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s32(vcreate_s32(UINT64_C(0xffff52e9a74d0000)),
                          vcreate_s32(UINT64_C(0x800080000000bf7b)));
      arg2 = vcreate_s16(UINT64_C(0x800000008000ffff));
      arg3 = vcombine_s16(vcreate_s16(UINT64_C(0xd52c7fff8000ffff)),
                          vcreate_s16(UINT64_C(0xffffdf817fff8633)));
      clear_neon_saturated();
      //  Expect: "result" = ffff80000000bf7b7ffe52e9a74dfffe
      result = vqdmlsl_laneq_s16(arg1, arg2, arg3, 2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 0);
         exp = UINT64_C(0x7ffe52e9a74dfffe);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 1);
         exp = UINT64_C(0xffff80000000bf7b);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2492() {

{
   {
      int32x4_t arg1;
      int16x8_t arg2;
      int16x4_t arg3;
      int32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"qdmls_lane\", fnname = \"vqdmlsl_high_lane_s16\", rettype = \"int32x4_t\", argtypes = \"[int32x4_t,int16x8_t,int16x4_t,__constrange(0,3) int]\", vals = [VectorVal [IntegerVal (-1493027013),IntegerVal (-65536),IntegerVal (-32769),IntegerVal 2147418112],VectorVal [IntegerVal (-1),IntegerVal 31207,IntegerVal 6042,IntegerVal 635,IntegerVal 18343,IntegerVal 4384,IntegerVal 32767,IntegerVal 0],VectorVal [IntegerVal (-14186),IntegerVal 32767,IntegerVal 0,IntegerVal (-32768)],IndexVal 1], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s32(vcreate_s32(UINT64_C(0xffff0000a702373b)),
                          vcreate_s32(UINT64_C(0x7fff0000ffff7fff)));
      arg2 = vcombine_s16(vcreate_s16(UINT64_C(0x027b179a79e7ffff)),
                          vcreate_s16(UINT64_C(0x00007fff112047a7)));
      arg3 = vcreate_s16(UINT64_C(0x800000007fffc896));
      clear_neon_saturated();
      //  Expect: "result" = 7fff000080017ffdeedf224080000000
      result = vqdmlsl_high_lane_s16(arg1, arg2, arg3, 1);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 0);
         exp = UINT64_C(0xeedf224080000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 1);
         exp = UINT64_C(0x7fff000080017ffd);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2493() {

{
   {
      int32x4_t arg1;
      int16x8_t arg2;
      int16x8_t arg3;
      int32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"qdmls_lane\", fnname = \"vqdmlsl_high_laneq_s16\", rettype = \"int32x4_t\", argtypes = \"[int32x4_t,int16x8_t,int16x8_t,__constrange(0,7) int]\", vals = [VectorVal [IntegerVal 2147418112,IntegerVal 32767,IntegerVal (-259751936),IntegerVal (-65536)],VectorVal [IntegerVal 32767,IntegerVal 32767,IntegerVal (-1),IntegerVal 0,IntegerVal 3045,IntegerVal (-29257),IntegerVal 32767,IntegerVal 9517],VectorVal [IntegerVal (-32768),IntegerVal 0,IntegerVal 10299,IntegerVal (-32768),IntegerVal (-6788),IntegerVal (-1),IntegerVal 0,IntegerVal (-32768)],IndexVal 0], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s32(vcreate_s32(UINT64_C(0x00007fff7fff0000)),
                          vcreate_s32(UINT64_C(0xffff0000f0848000)));
      arg2 = vcombine_s16(vcreate_s16(UINT64_C(0x0000ffff7fff7fff)),
                          vcreate_s16(UINT64_C(0x252d7fff8db70be5)));
      arg3 = vcombine_s16(vcreate_s16(UINT64_C(0x8000283b00008000)),
                          vcreate_s16(UINT64_C(0x80000000ffffe57c)));
      clear_neon_saturated();
      //  Expect: "result" = 252c0000708380008db77fff7fffffff
      result = vqdmlsl_high_laneq_s16(arg1, arg2, arg3, 0);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 0);
         exp = UINT64_C(0x8db77fff7fffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 1);
         exp = UINT64_C(0x252c000070838000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2494() {

{
   {
      int64x2_t arg1;
      int32x2_t arg2;
      int32x2_t arg3;
      int64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"qdmls_lane\", fnname = \"vqdmlsl_lane_s32\", rettype = \"int64x2_t\", argtypes = \"[int64x2_t,int32x2_t,int32x2_t,__constrange(0,1) int]\", vals = [VectorVal [IntegerVal 140735340886768,IntegerVal (-9223231295071453185)],VectorVal [IntegerVal (-1),IntegerVal (-2147450880)],VectorVal [IntegerVal (-2147450880),IntegerVal 2147418112],IndexVal 0], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s64(vcreate_s64(UINT64_C(0x00007fff80003af0)),
                          vcreate_s64(UINT64_C(0x80008000ffffffff)));
      arg2 = vcreate_s32(UINT64_C(0x80008000ffffffff));
      arg3 = vcreate_s32(UINT64_C(0x7fff000080008000));
      clear_neon_saturated();
      //  Expect: "result" = 800000000000000000007ffe80013af0
      result = vqdmlsl_lane_s32(arg1, arg2, arg3, 0);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 0);
         exp = UINT64_C(0x00007ffe80013af0);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 1);
         exp = UINT64_C(0x8000000000000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2495() {

{
   {
      int64x2_t arg1;
      int32x2_t arg2;
      int32x4_t arg3;
      int64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"qdmls_lane\", fnname = \"vqdmlsl_laneq_s32\", rettype = \"int64x2_t\", argtypes = \"[int64x2_t,int32x2_t,int32x4_t,__constrange(0,3) int]\", vals = [VectorVal [IntegerVal (-9223231296834273281),IntegerVal 281472829278810],VectorVal [IntegerVal 2147450879,IntegerVal 2147483647],VectorVal [IntegerVal 1820278110,IntegerVal 32768,IntegerVal 636776722,IntegerVal 2147450879],IndexVal 2], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s64(vcreate_s64(UINT64_C(0x8000800096ed7fff)),
                          vcreate_s64(UINT64_C(0x0000ffff8000ca5a)));
      arg2 = vcreate_s32(UINT64_C(0x7fffffff7fff7fff));
      arg3 = vcombine_s32(vcreate_s32(UINT64_C(0x000080006c7f3d5e)),
                          vcreate_s32(UINT64_C(0x7fff7fff25f47112)));
      clear_neon_saturated();
      //  Expect: "result" = da0c8eedcbe9ac7e8000000000000000
      result = vqdmlsl_laneq_s32(arg1, arg2, arg3, 2);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 0);
         exp = UINT64_C(0x8000000000000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 1);
         exp = UINT64_C(0xda0c8eedcbe9ac7e);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2496() {

{
   {
      int64x2_t arg1;
      int32x4_t arg2;
      int32x2_t arg3;
      int64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"qdmls_lane\", fnname = \"vqdmlsl_high_lane_s32\", rettype = \"int64x2_t\", argtypes = \"[int64x2_t,int32x4_t,int32x2_t,__constrange(0,1) int]\", vals = [VectorVal [IntegerVal 162119983038463,IntegerVal (-140739635904512)],VectorVal [IntegerVal (-2147418113),IntegerVal (-2147420039),IntegerVal (-38814),IntegerVal 325386240],VectorVal [IntegerVal 291045375,IntegerVal 32767],IndexVal 1], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s64(vcreate_s64(UINT64_C(0x000093727fffffff)),
                          vcreate_s64(UINT64_C(0xffff7fff7fff0000)));
      arg2 = vcombine_s32(vcreate_s32(UINT64_C(0x8000f8798000ffff)),
                          vcreate_s32(UINT64_C(0x13650000ffff6862)));
      arg3 = vcreate_s32(UINT64_C(0x00007fff1158ffff));
      clear_neon_saturated();
      //  Expect: "result" = ffff6c9aa6c9000000009373179cd0c3
      result = vqdmlsl_high_lane_s32(arg1, arg2, arg3, 1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 0);
         exp = UINT64_C(0x00009373179cd0c3);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 1);
         exp = UINT64_C(0xffff6c9aa6c90000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2497() {

{
   {
      int64x2_t arg1;
      int32x4_t arg2;
      int32x4_t arg3;
      int64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"qdmls_lane\", fnname = \"vqdmlsl_high_laneq_s32\", rettype = \"int64x2_t\", argtypes = \"[int64x2_t,int32x4_t,int32x4_t,__constrange(0,3) int]\", vals = [VectorVal [IntegerVal (-9223090564025581568),IntegerVal 243949847499393],VectorVal [IntegerVal 493879295,IntegerVal (-2147448240),IntegerVal 1480130559,IntegerVal 2147450879],VectorVal [IntegerVal 2147418112,IntegerVal 32767,IntegerVal (-2147450881),IntegerVal 65535],IndexVal 3], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s64(vcreate_s64(UINT64_C(0x8000ffff7fff8000)),
                          vcreate_s64(UINT64_C(0x0000dddf0000d281)));
      arg2 = vcombine_s32(vcreate_s32(UINT64_C(0x80008a501d6fffff)),
                          vcreate_s32(UINT64_C(0x7fff7fff5838ffff)));
      arg3 = vcombine_s32(vcreate_s32(UINT64_C(0x00007fff7fff0000)),
                          vcreate_s32(UINT64_C(0x0000ffff80007fff)));
      clear_neon_saturated();
      //  Expect: "result" = ffffdde10001d27f80004f8e30737ffe
      result = vqdmlsl_high_laneq_s32(arg1, arg2, arg3, 3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 0);
         exp = UINT64_C(0x80004f8e30737ffe);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 1);
         exp = UINT64_C(0xffffdde10001d27f);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2498() {

{
   {
      int32_t arg1;
      int16_t arg2;
      int16x4_t arg3;
      int32_t result;
      char* str1 = "ReproInfo2 {semantics = \"qdmls_lane\", fnname = \"vqdmlslh_lane_s16\", rettype = \"int32_t\", argtypes = \"[int32_t,int16_t,int16x4_t,__constrange(0,3) int]\", vals = [IntegerVal 0,IntegerVal 32767,VectorVal [IntegerVal (-32768),IntegerVal (-32768),IntegerVal (-31803),IntegerVal 16087],IndexVal 2], start_saturated = False}";
      int reported = 0;
      int32_t got;
      int32_t exp;
      arg1 = 0;
      arg2 = 32767;
      arg3 = vcreate_s16(UINT64_C(0x3ed783c580008000));
      clear_neon_saturated();
      //  Expect: "result" = 7c3a078a
      result = vqdmlslh_lane_s16(arg1, arg2, arg3, 2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = 2084177802;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIi32 " Got: %" PRIi32 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2499() {

{
   {
      int32_t arg1;
      int16_t arg2;
      int16x8_t arg3;
      int32_t result;
      char* str1 = "ReproInfo2 {semantics = \"qdmls_lane\", fnname = \"vqdmlslh_laneq_s16\", rettype = \"int32_t\", argtypes = \"[int32_t,int16_t,int16x8_t,__constrange(0,7) int]\", vals = [IntegerVal 2147483647,IntegerVal 0,VectorVal [IntegerVal (-32768),IntegerVal 8432,IntegerVal (-3754),IntegerVal (-17398),IntegerVal (-32768),IntegerVal 32767,IntegerVal 0,IntegerVal 32767],IndexVal 6], start_saturated = False}";
      int reported = 0;
      int32_t got;
      int32_t exp;
      arg1 = 2147483647;
      arg2 = 0;
      arg3 = vcombine_s16(vcreate_s16(UINT64_C(0xbc0af15620f08000)),
                          vcreate_s16(UINT64_C(0x7fff00007fff8000)));
      clear_neon_saturated();
      //  Expect: "result" = 7fffffff
      result = vqdmlslh_laneq_s16(arg1, arg2, arg3, 6);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = 2147483647;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIi32 " Got: %" PRIi32 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2500() {

{
   {
      int64_t arg1;
      int32_t arg2;
      int32x2_t arg3;
      int64_t result;
      char* str1 = "ReproInfo2 {semantics = \"qdmls_lane\", fnname = \"vqdmlsls_lane_s32\", rettype = \"int64_t\", argtypes = \"[int64_t,int32_t,int32x2_t,__constrange(0,1) int]\", vals = [IntegerVal 9223292622909440000,IntegerVal 2147418112,VectorVal [IntegerVal (-2147450881),IntegerVal (-344522752)],IndexVal 1], start_saturated = False}";
      int reported = 0;
      int64_t got;
      int64_t exp;
      arg1 = INT64_C(9223292622909440000);
      arg2 = 2147418112;
      arg3 = vcreate_s32(UINT64_C(0xeb77000080007fff));
      clear_neon_saturated();
      //  Expect: "result" = 7fffffffffffffff
      result = vqdmlsls_lane_s32(arg1, arg2, arg3, 1);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      got = result;
      exp = INT64_C(9223372036854775807);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIi64 " Got: %" PRIi64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2501() {

{
   {
      int64_t arg1;
      int32_t arg2;
      int32x4_t arg3;
      int64_t result;
      char* str1 = "ReproInfo2 {semantics = \"qdmls_lane\", fnname = \"vqdmlsls_laneq_s32\", rettype = \"int64_t\", argtypes = \"[int64_t,int32_t,int32x4_t,__constrange(0,3) int]\", vals = [IntegerVal 9223231303661355007,IntegerVal 65535,VectorVal [IntegerVal 65535,IntegerVal 32768,IntegerVal 0,IntegerVal (-1)],IndexVal 1], start_saturated = False}";
      int reported = 0;
      int64_t got;
      int64_t exp;
      arg1 = INT64_C(9223231303661355007);
      arg2 = 65535;
      arg3 = vcombine_s32(vcreate_s32(UINT64_C(0x000080000000ffff)),
                          vcreate_s32(UINT64_C(0xffffffff00000000)));
      clear_neon_saturated();
      //  Expect: "result" = 7fff800000007fff
      result = vqdmlsls_laneq_s32(arg1, arg2, arg3, 1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = INT64_C(9223231299366453247);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIi64 " Got: %" PRIi64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2502() {

{
   {
      int16x4_t arg1;
      int16x4_t arg2;
      int32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"mul_lane\", fnname = \"vmull_lane_s16\", rettype = \"int32x4_t\", argtypes = \"[int16x4_t,int16x4_t,__constrange(0,3) int]\", vals = [VectorVal [IntegerVal (-32768),IntegerVal (-1),IntegerVal 32767,IntegerVal (-32768)],VectorVal [IntegerVal 0,IntegerVal 0,IntegerVal 32767,IntegerVal (-32768)],IndexVal 3], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_s16(UINT64_C(0x80007fffffff8000));
      arg2 = vcreate_s16(UINT64_C(0x80007fff00000000));
      clear_neon_saturated();
      //  Expect: "result" = 40000000c00080000000800040000000
      result = vmull_lane_s16(arg1, arg2, 3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 0);
         exp = UINT64_C(0x0000800040000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 1);
         exp = UINT64_C(0x40000000c0008000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2503() {

{
   {
      int16x4_t arg1;
      int16x8_t arg2;
      int32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"mul_lane\", fnname = \"vmull_laneq_s16\", rettype = \"int32x4_t\", argtypes = \"[int16x4_t,int16x8_t,__constrange(0,7) int]\", vals = [VectorVal [IntegerVal 0,IntegerVal 32767,IntegerVal (-25747),IntegerVal 32767],VectorVal [IntegerVal (-9889),IntegerVal 0,IntegerVal 0,IntegerVal 0,IntegerVal (-32768),IntegerVal 32767,IntegerVal (-1),IntegerVal (-1)],IndexVal 3], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_s16(UINT64_C(0x7fff9b6d7fff0000));
      arg2 = vcombine_s16(vcreate_s16(UINT64_C(0x000000000000d95f)),
                          vcreate_s16(UINT64_C(0xffffffff7fff8000)));
      clear_neon_saturated();
      //  Expect: "result" = 00000000000000000000000000000000
      result = vmull_laneq_s16(arg1, arg2, 3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 0);
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 1);
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2504() {

{
   {
      int32x2_t arg1;
      int32x2_t arg2;
      int64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"mul_lane\", fnname = \"vmull_lane_s32\", rettype = \"int64x2_t\", argtypes = \"[int32x2_t,int32x2_t,__constrange(0,1) int]\", vals = [VectorVal [IntegerVal 62658,IntegerVal (-32769)],VectorVal [IntegerVal 32768,IntegerVal (-2147483648)],IndexVal 1], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_s32(UINT64_C(0xffff7fff0000f4c2));
      arg2 = vcreate_s32(UINT64_C(0x8000000000008000));
      clear_neon_saturated();
      //  Expect: "result" = 0000400080000000ffff859f00000000
      result = vmull_lane_s32(arg1, arg2, 1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 0);
         exp = UINT64_C(0xffff859f00000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 1);
         exp = UINT64_C(0x0000400080000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2505() {

{
   {
      int32x2_t arg1;
      int32x4_t arg2;
      int64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"mul_lane\", fnname = \"vmull_laneq_s32\", rettype = \"int64x2_t\", argtypes = \"[int32x2_t,int32x4_t,__constrange(0,3) int]\", vals = [VectorVal [IntegerVal 935395327,IntegerVal 2147450879],VectorVal [IntegerVal (-1465882111),IntegerVal (-1505664116),IntegerVal (-32769),IntegerVal 32767],IndexVal 2], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_s32(UINT64_C(0x7fff7fff37c0ffff));
      arg2 = vcombine_s32(vcreate_s32(UINT64_C(0xa641638ca8a06a01)),
                          vcreate_s32(UINT64_C(0x00007fffffff7fff)));
      clear_neon_saturated();
      //  Expect: "result" = ffffbfffc0010001ffffe41f483f8001
      result = vmull_laneq_s32(arg1, arg2, 2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 0);
         exp = UINT64_C(0xffffe41f483f8001);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 1);
         exp = UINT64_C(0xffffbfffc0010001);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2506() {

{
   {
      uint16x4_t arg1;
      uint16x4_t arg2;
      uint32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"mul_lane\", fnname = \"vmull_lane_u16\", rettype = \"uint32x4_t\", argtypes = \"[uint16x4_t,uint16x4_t,__constrange(0,3) int]\", vals = [VectorVal [IntegerVal 0,IntegerVal 32767,IntegerVal 32767,IntegerVal 50322],VectorVal [IntegerVal 0,IntegerVal 65535,IntegerVal 57747,IntegerVal 0],IndexVal 0], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_u16(UINT64_C(0xc4927fff7fff0000));
      arg2 = vcreate_u16(UINT64_C(0x0000e193ffff0000));
      clear_neon_saturated();
      //  Expect: "result" = 00000000000000000000000000000000
      result = vmull_lane_u16(arg1, arg2, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 0);
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 1);
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2507() {

{
   {
      uint16x4_t arg1;
      uint16x8_t arg2;
      uint32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"mul_lane\", fnname = \"vmull_laneq_u16\", rettype = \"uint32x4_t\", argtypes = \"[uint16x4_t,uint16x8_t,__constrange(0,7) int]\", vals = [VectorVal [IntegerVal 32767,IntegerVal 53080,IntegerVal 65535,IntegerVal 32767],VectorVal [IntegerVal 11454,IntegerVal 51911,IntegerVal 0,IntegerVal 40141,IntegerVal 32768,IntegerVal 0,IntegerVal 7823,IntegerVal 32767],IndexVal 6], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_u16(UINT64_C(0x7fffffffcf587fff));
      arg2 = vcombine_u16(vcreate_u16(UINT64_C(0x9ccd0000cac72cbe)),
                          vcreate_u16(UINT64_C(0x7fff1e8f00008000)));
      clear_neon_saturated();
      //  Expect: "result" = 0f4761711e8ee17118c022280f476171
      result = vmull_laneq_u16(arg1, arg2, 6);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 0);
         exp = UINT64_C(0x18c022280f476171);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 1);
         exp = UINT64_C(0x0f4761711e8ee171);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2508() {

{
   {
      uint32x2_t arg1;
      uint32x2_t arg2;
      uint64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"mul_lane\", fnname = \"vmull_lane_u32\", rettype = \"uint64x2_t\", argtypes = \"[uint32x2_t,uint32x2_t,__constrange(0,1) int]\", vals = [VectorVal [IntegerVal 2147516415,IntegerVal 2147516416],VectorVal [IntegerVal 2362377865,IntegerVal 45486],IndexVal 0], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_u32(UINT64_C(0x8000800080007fff));
      arg2 = vcreate_u32(UINT64_C(0x0000b1ae8ccf0689));
      clear_neon_saturated();
      //  Expect: "result" = 4667c9ac034480004667c9ab76757977
      result = vmull_lane_u32(arg1, arg2, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 0);
         exp = UINT64_C(0x4667c9ab76757977);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 1);
         exp = UINT64_C(0x4667c9ac03448000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2509() {

{
   {
      uint32x2_t arg1;
      uint32x4_t arg2;
      uint64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"mul_lane\", fnname = \"vmull_laneq_u32\", rettype = \"uint64x2_t\", argtypes = \"[uint32x2_t,uint32x4_t,__constrange(0,3) int]\", vals = [VectorVal [IntegerVal 2147450880,IntegerVal 4294935314],VectorVal [IntegerVal 2147516415,IntegerVal 1421672447,IntegerVal 4294934527,IntegerVal 4294901760],IndexVal 0], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_u32(UINT64_C(0xffff83127fff8000));
      arg2 = vcombine_u32(vcreate_u32(UINT64_C(0x54bcffff80007fff)),
                          vcreate_u32(UINT64_C(0xffff0000ffff7fff)));
      clear_neon_saturated();
      //  Expect: "result" = 80004187c1897cee3fffffff40008000
      result = vmull_laneq_u32(arg1, arg2, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 0);
         exp = UINT64_C(0x3fffffff40008000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 1);
         exp = UINT64_C(0x80004187c1897cee);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2510() {

{
   {
      int16x8_t arg1;
      int16x4_t arg2;
      int32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"mul_lane\", fnname = \"vmull_high_lane_s16\", rettype = \"int32x4_t\", argtypes = \"[int16x8_t,int16x4_t,__constrange(0,3) int]\", vals = [VectorVal [IntegerVal (-1),IntegerVal (-32768),IntegerVal 0,IntegerVal (-1),IntegerVal (-32768),IntegerVal 0,IntegerVal (-1559),IntegerVal (-1)],VectorVal [IntegerVal (-3395),IntegerVal (-31256),IntegerVal 32767,IntegerVal 563],IndexVal 1], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s16(vcreate_s16(UINT64_C(0xffff00008000ffff)),
                          vcreate_s16(UINT64_C(0xfffff9e900008000)));
      arg2 = vcreate_s16(UINT64_C(0x02337fff85e8f2bd));
      clear_neon_saturated();
      //  Expect: "result" = 00007a1802e78828000000003d0c0000
      result = vmull_high_lane_s16(arg1, arg2, 1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 0);
         exp = UINT64_C(0x000000003d0c0000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 1);
         exp = UINT64_C(0x00007a1802e78828);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2511() {

{
   {
      int16x8_t arg1;
      int16x8_t arg2;
      int32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"mul_lane\", fnname = \"vmull_high_laneq_s16\", rettype = \"int32x4_t\", argtypes = \"[int16x8_t,int16x8_t,__constrange(0,7) int]\", vals = [VectorVal [IntegerVal (-27650),IntegerVal 0,IntegerVal 0,IntegerVal (-32768),IntegerVal (-1),IntegerVal (-1),IntegerVal (-29051),IntegerVal (-32768)],VectorVal [IntegerVal (-1),IntegerVal (-32768),IntegerVal (-1),IntegerVal (-1),IntegerVal (-1),IntegerVal 0,IntegerVal (-32768),IntegerVal 0],IndexVal 3], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s16(vcreate_s16(UINT64_C(0x80000000000093fe)),
                          vcreate_s16(UINT64_C(0x80008e85ffffffff)));
      arg2 = vcombine_s16(vcreate_s16(UINT64_C(0xffffffff8000ffff)),
                          vcreate_s16(UINT64_C(0x000080000000ffff)));
      clear_neon_saturated();
      //  Expect: "result" = 000080000000717b0000000100000001
      result = vmull_high_laneq_s16(arg1, arg2, 3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 0);
         exp = UINT64_C(0x0000000100000001);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 1);
         exp = UINT64_C(0x000080000000717b);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2512() {

{
   {
      int32x4_t arg1;
      int32x2_t arg2;
      int64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"mul_lane\", fnname = \"vmull_high_lane_s32\", rettype = \"int64x2_t\", argtypes = \"[int32x4_t,int32x2_t,__constrange(0,1) int]\", vals = [VectorVal [IntegerVal 2147418112,IntegerVal 32767,IntegerVal 2147450880,IntegerVal 32768],VectorVal [IntegerVal (-2147483648),IntegerVal 65535],IndexVal 1], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s32(vcreate_s32(UINT64_C(0x00007fff7fff0000)),
                          vcreate_s32(UINT64_C(0x000080007fff8000)));
      arg2 = vcreate_s32(UINT64_C(0x0000ffff80000000));
      clear_neon_saturated();
      //  Expect: "result" = 000000007fff800000007fff00008000
      result = vmull_high_lane_s32(arg1, arg2, 1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 0);
         exp = UINT64_C(0x00007fff00008000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 1);
         exp = UINT64_C(0x000000007fff8000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2513() {

{
   {
      int32x4_t arg1;
      int32x4_t arg2;
      int64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"mul_lane\", fnname = \"vmull_high_laneq_s32\", rettype = \"int64x2_t\", argtypes = \"[int32x4_t,int32x4_t,__constrange(0,3) int]\", vals = [VectorVal [IntegerVal (-32769),IntegerVal (-2147418113),IntegerVal 32767,IntegerVal (-8624)],VectorVal [IntegerVal 32768,IntegerVal 2147483647,IntegerVal (-2147418113),IntegerVal (-1)],IndexVal 2], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s32(vcreate_s32(UINT64_C(0x8000ffffffff7fff)),
                          vcreate_s32(UINT64_C(0xffffde5000007fff)));
      arg2 = vcombine_s32(vcreate_s32(UINT64_C(0x7fffffff00008000)),
                          vcreate_s32(UINT64_C(0xffffffff8000ffff)));
      clear_neon_saturated();
      //  Expect: "result" = 000010d7de5021b0ffffc000fffe8001
      result = vmull_high_laneq_s32(arg1, arg2, 2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 0);
         exp = UINT64_C(0xffffc000fffe8001);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 1);
         exp = UINT64_C(0x000010d7de5021b0);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2514() {

{
   {
      uint16x8_t arg1;
      uint16x4_t arg2;
      uint32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"mul_lane\", fnname = \"vmull_high_lane_u16\", rettype = \"uint32x4_t\", argtypes = \"[uint16x8_t,uint16x4_t,__constrange(0,3) int]\", vals = [VectorVal [IntegerVal 65535,IntegerVal 65535,IntegerVal 32767,IntegerVal 32767,IntegerVal 32767,IntegerVal 32767,IntegerVal 32768,IntegerVal 32768],VectorVal [IntegerVal 2029,IntegerVal 65535,IntegerVal 0,IntegerVal 6359],IndexVal 2], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u16(vcreate_u16(UINT64_C(0x7fff7fffffffffff)),
                          vcreate_u16(UINT64_C(0x800080007fff7fff)));
      arg2 = vcreate_u16(UINT64_C(0x18d70000ffff07ed));
      clear_neon_saturated();
      //  Expect: "result" = 00000000000000000000000000000000
      result = vmull_high_lane_u16(arg1, arg2, 2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 0);
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 1);
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2515() {

{
   {
      uint16x8_t arg1;
      uint16x8_t arg2;
      uint32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"mul_lane\", fnname = \"vmull_high_laneq_u16\", rettype = \"uint32x4_t\", argtypes = \"[uint16x8_t,uint16x8_t,__constrange(0,7) int]\", vals = [VectorVal [IntegerVal 65535,IntegerVal 65535,IntegerVal 32768,IntegerVal 32767,IntegerVal 0,IntegerVal 65535,IntegerVal 32767,IntegerVal 32767],VectorVal [IntegerVal 32768,IntegerVal 65535,IntegerVal 65535,IntegerVal 21103,IntegerVal 21874,IntegerVal 32767,IntegerVal 65535,IntegerVal 32767],IndexVal 4], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u16(vcreate_u16(UINT64_C(0x7fff8000ffffffff)),
                          vcreate_u16(UINT64_C(0x7fff7fffffff0000)));
      arg2 = vcombine_u16(vcreate_u16(UINT64_C(0x526fffffffff8000)),
                          vcreate_u16(UINT64_C(0x7fffffff7fff5572)));
      clear_neon_saturated();
      //  Expect: "result" = 2ab8aa8e2ab8aa8e5571aa8e00000000
      result = vmull_high_laneq_u16(arg1, arg2, 4);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 0);
         exp = UINT64_C(0x5571aa8e00000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 1);
         exp = UINT64_C(0x2ab8aa8e2ab8aa8e);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2516() {

{
   {
      uint32x4_t arg1;
      uint32x2_t arg2;
      uint64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"mul_lane\", fnname = \"vmull_high_lane_u32\", rettype = \"uint64x2_t\", argtypes = \"[uint32x4_t,uint32x2_t,__constrange(0,1) int]\", vals = [VectorVal [IntegerVal 3092567727,IntegerVal 32767,IntegerVal 3396468736,IntegerVal 4294901760],VectorVal [IntegerVal 2147450879,IntegerVal 2147450880],IndexVal 0], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u32(vcreate_u32(UINT64_C(0x00007fffb854d6af)),
                          vcreate_u32(UINT64_C(0xffff0000ca720000)));
      arg2 = vcreate_u32(UINT64_C(0x7fff80007fff7fff));
      clear_neon_saturated();
      //  Expect: "result" = 7ffeffff8001000065389ac6358e0000
      result = vmull_high_lane_u32(arg1, arg2, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 0);
         exp = UINT64_C(0x65389ac6358e0000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 1);
         exp = UINT64_C(0x7ffeffff80010000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2517() {

{
   {
      uint32x4_t arg1;
      uint32x4_t arg2;
      uint64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"mul_lane\", fnname = \"vmull_high_laneq_u32\", rettype = \"uint64x2_t\", argtypes = \"[uint32x4_t,uint32x4_t,__constrange(0,3) int]\", vals = [VectorVal [IntegerVal 2147539312,IntegerVal 1575059456,IntegerVal 32768,IntegerVal 2147443052],VectorVal [IntegerVal 4294967295,IntegerVal 2774728704,IntegerVal 3820978175,IntegerVal 2147516415],IndexVal 3], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u32(vcreate_u32(UINT64_C(0x5de180008000d970)),
                          vcreate_u32(UINT64_C(0x7fff616c00008000)));
      arg2 = vcombine_u32(vcreate_u32(UINT64_C(0xa5630000ffffffff)),
                          vcreate_u32(UINT64_C(0x80007fffe3bf7fff)));
      clear_neon_saturated();
      //  Expect: "result" = 3ffff0b530b69e94000040003fff8000
      result = vmull_high_laneq_u32(arg1, arg2, 3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 0);
         exp = UINT64_C(0x000040003fff8000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 1);
         exp = UINT64_C(0x3ffff0b530b69e94);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2518() {

{
   {
      int16x4_t arg1;
      int16x4_t arg2;
      int16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"mul_lane\", fnname = \"vmul_lane_s16\", rettype = \"int16x4_t\", argtypes = \"[int16x4_t,int16x4_t,__constrange(0,3) int]\", vals = [VectorVal [IntegerVal (-32768),IntegerVal 16850,IntegerVal (-32768),IntegerVal (-18808)],VectorVal [IntegerVal 32767,IntegerVal 0,IntegerVal 0,IntegerVal 5066],IndexVal 2], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s16(UINT64_C(0xb688800041d28000));
      arg2 = vcreate_s16(UINT64_C(0x13ca000000007fff));
      clear_neon_saturated();
      //  Expect: "result" = 0000000000000000
      result = vmul_lane_s16(arg1, arg2, 2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s16(result), 0);
      exp = 0;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2519() {

{
   {
      int16x4_t arg1;
      int16x8_t arg2;
      int16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"mul_lane\", fnname = \"vmul_laneq_s16\", rettype = \"int16x4_t\", argtypes = \"[int16x4_t,int16x8_t,__constrange(0,7) int]\", vals = [VectorVal [IntegerVal (-2853),IntegerVal (-32768),IntegerVal 0,IntegerVal (-1)],VectorVal [IntegerVal (-1),IntegerVal 32767,IntegerVal (-1),IntegerVal (-1),IntegerVal 0,IntegerVal 2571,IntegerVal 32767,IntegerVal (-1)],IndexVal 5], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s16(UINT64_C(0xffff00008000f4db));
      arg2 = vcombine_s16(vcreate_s16(UINT64_C(0xffffffff7fffffff)),
                          vcreate_s16(UINT64_C(0xffff7fff0a0b0000)));
      clear_neon_saturated();
      //  Expect: "result" = f5f5000080001369
      result = vmul_laneq_s16(arg1, arg2, 5);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s16(result), 0);
      exp = UINT64_C(0xf5f5000080001369);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2520() {

{
   {
      int32x2_t arg1;
      int32x2_t arg2;
      int32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"mul_lane\", fnname = \"vmul_lane_s32\", rettype = \"int32x2_t\", argtypes = \"[int32x2_t,int32x2_t,__constrange(0,1) int]\", vals = [VectorVal [IntegerVal 2147418112,IntegerVal 32768],VectorVal [IntegerVal 2147418112,IntegerVal 2147418112],IndexVal 1], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s32(UINT64_C(0x000080007fff0000));
      arg2 = vcreate_s32(UINT64_C(0x7fff00007fff0000));
      clear_neon_saturated();
      //  Expect: "result" = 8000000000000000
      result = vmul_lane_s32(arg1, arg2, 1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s32(result), 0);
      exp = UINT64_C(0x8000000000000000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2521() {

{
   {
      int32x2_t arg1;
      int32x4_t arg2;
      int32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"mul_lane\", fnname = \"vmul_laneq_s32\", rettype = \"int32x2_t\", argtypes = \"[int32x2_t,int32x4_t,__constrange(0,3) int]\", vals = [VectorVal [IntegerVal 2147450879,IntegerVal (-2147483648)],VectorVal [IntegerVal 0,IntegerVal 32768,IntegerVal 2147418112,IntegerVal 2147446368],IndexVal 2], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s32(UINT64_C(0x800000007fff7fff));
      arg2 = vcombine_s32(vcreate_s32(UINT64_C(0x0000800000000000)),
                          vcreate_s32(UINT64_C(0x7fff6e607fff0000)));
      clear_neon_saturated();
      //  Expect: "result" = 0000000000010000
      result = vmul_laneq_s32(arg1, arg2, 2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s32(result), 0);
      exp = UINT64_C(0x0000000000010000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2522() {

{
   {
      float32x2_t arg1;
      float32x2_t arg2;
      float32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"mul_lane\", fnname = \"vmul_lane_f32\", rettype = \"float32x2_t\", argtypes = \"[float32x2_t,float32x2_t,__constrange(0,1) int]\", vals = [VectorVal [FloatVal 0.6394988894462585,FloatVal 0.4986640214920044],VectorVal [FloatVal 0.21052342653274536,FloatVal 0.515769898891449],IndexVal 0], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_f32(UINT64_C(0x3eff50e43f23b633));
      arg2 = vcreate_f32(UINT64_C(0x3f04097f3e579374));
      clear_neon_saturated();
      //  Expect: "result" = 3dd6ffff3e09dc51
      result = vmul_lane_f32(arg1, arg2, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result, 0);
         exp = ((float32_t) 0.1346295028924942);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result, 1);
         exp = ((float32_t) 0.1049804612994194);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
   }
}
}
void dotests_2523() {

{
   {
      float32x2_t arg1;
      float32x4_t arg2;
      float32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"mul_lane\", fnname = \"vmul_laneq_f32\", rettype = \"float32x2_t\", argtypes = \"[float32x2_t,float32x4_t,__constrange(0,3) int]\", vals = [VectorVal [FloatVal 0.4907186031341553,FloatVal 0.6305283904075623],VectorVal [FloatVal 0.3755098581314087,FloatVal 0.7308984994888306,FloatVal 0.28368449211120605,FloatVal 0.9408994913101196],IndexVal 2], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_f32(UINT64_C(0x3f216a4f3efb3f78));
      arg2 = vcombine_f32(vcreate_f32(UINT64_C(0x3f3b1c2a3ec042d4)),
                          vcreate_f32(UINT64_C(0x3f70deca3e913f18)));
      clear_neon_saturated();
      //  Expect: "result" = 3e3729fe3e0e8cdf
      result = vmul_laneq_f32(arg1, arg2, 2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result, 0);
         exp = ((float32_t) 0.13920925557613373);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result, 1);
         exp = ((float32_t) 0.17887112498283386);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
   }
}
}
void dotests_2524() {

{
   {
      float64x1_t arg1;
      float64x1_t arg2;
      float64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"mul_lane\", fnname = \"vmul_lane_f64\", rettype = \"float64x1_t\", argtypes = \"[float64x1_t,float64x1_t,__constrange(0,0) int]\", vals = [VectorVal [FloatVal 0.9684872127286603],VectorVal [FloatVal 6.196542860088505e-2],IndexVal 0], start_saturated = False}";
      int reported = 0;
      float64_t got;
      float64_t exp;
      arg1 = vcreate_f64(UINT64_C(0x3feefdd8e52870fa));
      arg2 = vcreate_f64(UINT64_C(0x3fafb9eec2a597e0));
      clear_neon_saturated();
      //  Expect: "result" = 3faeb9fce86c7a87
      result = vmul_lane_f64(arg1, arg2, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_f64(result, 0);
      exp = 6.001272523120798e-2;
      if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
         }
   }
}
}
void dotests_2525() {

{
   {
      float64x1_t arg1;
      float64x2_t arg2;
      float64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"mul_lane\", fnname = \"vmul_laneq_f64\", rettype = \"float64x1_t\", argtypes = \"[float64x1_t,float64x2_t,__constrange(0,1) int]\", vals = [VectorVal [FloatVal 0.9839964731788566],VectorVal [FloatVal 0.4551474826589391,FloatVal 0.7747203978489531],IndexVal 0], start_saturated = False}";
      int reported = 0;
      float64_t got;
      float64_t exp;
      arg1 = vcreate_f64(UINT64_C(0x3fef7ce62bf5d74a));
      arg2 = vcombine_f64(vcreate_f64(UINT64_C(0x3fdd2122e8381ea6)),
                          vcreate_f64(UINT64_C(0x3fe8ca826e89c587)));
      clear_neon_saturated();
      //  Expect: "result" = 3fdca9cbbe696cd0
      result = vmul_laneq_f64(arg1, arg2, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_f64(result, 0);
      exp = 0.4478635177126309;
      if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
         }
   }
}
}
void dotests_2526() {

{
   {
      uint16x4_t arg1;
      uint16x4_t arg2;
      uint16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"mul_lane\", fnname = \"vmul_lane_u16\", rettype = \"uint16x4_t\", argtypes = \"[uint16x4_t,uint16x4_t,__constrange(0,3) int]\", vals = [VectorVal [IntegerVal 32768,IntegerVal 64695,IntegerVal 32767,IntegerVal 17862],VectorVal [IntegerVal 32767,IntegerVal 0,IntegerVal 0,IntegerVal 32768],IndexVal 0], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u16(UINT64_C(0x45c67ffffcb78000));
      arg2 = vcreate_u16(UINT64_C(0x8000000000007fff));
      clear_neon_saturated();
      //  Expect: "result" = ba3a000183498000
      result = vmul_lane_u16(arg1, arg2, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u16(result), 0);
      exp = UINT64_C(0xba3a000183498000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2527() {

{
   {
      uint16x4_t arg1;
      uint16x8_t arg2;
      uint16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"mul_lane\", fnname = \"vmul_laneq_u16\", rettype = \"uint16x4_t\", argtypes = \"[uint16x4_t,uint16x8_t,__constrange(0,7) int]\", vals = [VectorVal [IntegerVal 32768,IntegerVal 32767,IntegerVal 32767,IntegerVal 65535],VectorVal [IntegerVal 32767,IntegerVal 25472,IntegerVal 9091,IntegerVal 15738,IntegerVal 0,IntegerVal 65535,IntegerVal 32767,IntegerVal 32768],IndexVal 4], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u16(UINT64_C(0xffff7fff7fff8000));
      arg2 = vcombine_u16(vcreate_u16(UINT64_C(0x3d7a238363807fff)),
                          vcreate_u16(UINT64_C(0x80007fffffff0000)));
      clear_neon_saturated();
      //  Expect: "result" = 0000000000000000
      result = vmul_laneq_u16(arg1, arg2, 4);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u16(result), 0);
      exp = 0;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2528() {

{
   {
      uint32x2_t arg1;
      uint32x2_t arg2;
      uint32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"mul_lane\", fnname = \"vmul_lane_u32\", rettype = \"uint32x2_t\", argtypes = \"[uint32x2_t,uint32x2_t,__constrange(0,1) int]\", vals = [VectorVal [IntegerVal 4294934527,IntegerVal 4294901760],VectorVal [IntegerVal 2147483648,IntegerVal 4141088768],IndexVal 0], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u32(UINT64_C(0xffff0000ffff7fff));
      arg2 = vcreate_u32(UINT64_C(0xf6d4000080000000));
      clear_neon_saturated();
      //  Expect: "result" = 0000000080000000
      result = vmul_lane_u32(arg1, arg2, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u32(result), 0);
      exp = UINT64_C(0x0000000080000000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2529() {

{
   {
      uint32x2_t arg1;
      uint32x4_t arg2;
      uint32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"mul_lane\", fnname = \"vmul_laneq_u32\", rettype = \"uint32x2_t\", argtypes = \"[uint32x2_t,uint32x4_t,__constrange(0,3) int]\", vals = [VectorVal [IntegerVal 677,IntegerVal 2352212466],VectorVal [IntegerVal 2147418112,IntegerVal 2147516415,IntegerVal 2147430609,IntegerVal 2147450880],IndexVal 1], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u32(UINT64_C(0x8c33e9f2000002a5));
      arg2 = vcombine_u32(vcreate_u32(UINT64_C(0x80007fff7fff0000)),
                          vcreate_u32(UINT64_C(0x7fff80007fff30d1)));
      clear_neon_saturated();
      //  Expect: "result" = 68c5160e81527d5b
      result = vmul_laneq_u32(arg1, arg2, 1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u32(result), 0);
      exp = UINT64_C(0x68c5160e81527d5b);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2530() {

{
   {
      int16x8_t arg1;
      int16x4_t arg2;
      int16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"mul_lane\", fnname = \"vmulq_lane_s16\", rettype = \"int16x8_t\", argtypes = \"[int16x8_t,int16x4_t,__constrange(0,3) int]\", vals = [VectorVal [IntegerVal (-32768),IntegerVal 32767,IntegerVal 32767,IntegerVal 0,IntegerVal 28979,IntegerVal 32767,IntegerVal 0,IntegerVal (-1)],VectorVal [IntegerVal 0,IntegerVal 19218,IntegerVal (-1),IntegerVal 32767],IndexVal 3], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s16(vcreate_s16(UINT64_C(0x00007fff7fff8000)),
                          vcreate_s16(UINT64_C(0xffff00007fff7133)));
      arg2 = vcreate_s16(UINT64_C(0x7fffffff4b120000));
      clear_neon_saturated();
      //  Expect: "result" = 8001000000010ecd0000000100018000
      result = vmulq_lane_s16(arg1, arg2, 3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 0);
         exp = UINT64_C(0x0000000100018000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 1);
         exp = UINT64_C(0x8001000000010ecd);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2531() {

{
   {
      int16x8_t arg1;
      int16x8_t arg2;
      int16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"mul_lane\", fnname = \"vmulq_laneq_s16\", rettype = \"int16x8_t\", argtypes = \"[int16x8_t,int16x8_t,__constrange(0,7) int]\", vals = [VectorVal [IntegerVal (-1),IntegerVal (-1),IntegerVal (-23513),IntegerVal 31514,IntegerVal 0,IntegerVal (-4249),IntegerVal 0,IntegerVal 0],VectorVal [IntegerVal 32767,IntegerVal (-32768),IntegerVal (-1),IntegerVal 0,IntegerVal 32767,IntegerVal (-1),IntegerVal 0,IntegerVal 0],IndexVal 0], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s16(vcreate_s16(UINT64_C(0x7b1aa427ffffffff)),
                          vcreate_s16(UINT64_C(0x00000000ef670000)));
      arg2 = vcombine_s16(vcreate_s16(UINT64_C(0x0000ffff80007fff)),
                          vcreate_s16(UINT64_C(0x00000000ffff7fff)));
      clear_neon_saturated();
      //  Expect: "result" = 000000009099000084e6dbd980018001
      result = vmulq_laneq_s16(arg1, arg2, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 0);
         exp = UINT64_C(0x84e6dbd980018001);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 1);
         exp = UINT64_C(0x0000000090990000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2532() {

{
   {
      int32x4_t arg1;
      int32x2_t arg2;
      int32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"mul_lane\", fnname = \"vmulq_lane_s32\", rettype = \"int32x4_t\", argtypes = \"[int32x4_t,int32x2_t,__constrange(0,1) int]\", vals = [VectorVal [IntegerVal 65535,IntegerVal 2147450879,IntegerVal 2147450879,IntegerVal 32767],VectorVal [IntegerVal 2147450880,IntegerVal 32767],IndexVal 1], start_saturated = True}";
      int reported = 0;
      arg1 = vcombine_s32(vcreate_s32(UINT64_C(0x7fff7fff0000ffff)),
                          vcreate_s32(UINT64_C(0x00007fff7fff7fff)));
      arg2 = vcreate_s32(UINT64_C(0x00007fff7fff8000));
      set_neon_saturated();
      //  Expect: "result" = 3fff000140000001400000017ffe8001
      result = vmulq_lane_s32(arg1, arg2, 1);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 0);
         exp = UINT64_C(0x400000017ffe8001);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 1);
         exp = UINT64_C(0x3fff000140000001);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2533() {

{
   {
      int32x4_t arg1;
      int32x4_t arg2;
      int32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"mul_lane\", fnname = \"vmulq_laneq_s32\", rettype = \"int32x4_t\", argtypes = \"[int32x4_t,int32x4_t,__constrange(0,3) int]\", vals = [VectorVal [IntegerVal 32767,IntegerVal (-2147450881),IntegerVal 2147418112,IntegerVal 2147450880],VectorVal [IntegerVal (-2147418113),IntegerVal (-32769),IntegerVal 261816319,IntegerVal 2147450879],IndexVal 2], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s32(vcreate_s32(UINT64_C(0x80007fff00007fff)),
                          vcreate_s32(UINT64_C(0x7fff80007fff0000)));
      arg2 = vcombine_s32(vcreate_s32(UINT64_C(0xffff7fff8000ffff)),
                          vcreate_s32(UINT64_C(0x7fff7fff0f9affff)));
      clear_neon_saturated();
      //  Expect: "result" = 0000800080010000f064800170648001
      result = vmulq_laneq_s32(arg1, arg2, 2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 0);
         exp = UINT64_C(0xf064800170648001);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 1);
         exp = UINT64_C(0x0000800080010000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2534() {

{
   {
      float32x4_t arg1;
      float32x2_t arg2;
      float32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"mul_lane\", fnname = \"vmulq_lane_f32\", rettype = \"float32x4_t\", argtypes = \"[float32x4_t,float32x2_t,__constrange(0,1) int]\", vals = [VectorVal [FloatVal 0.6513856053352356,FloatVal 0.7429865002632141,FloatVal 0.1958138346672058,FloatVal 8.652615547180176e-2],VectorVal [FloatVal 0.5940557718276978,FloatVal 0.5633459687232971],IndexVal 0], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_f32(vcreate_f32(UINT64_C(0x3f3e345d3f26c135)),
                          vcreate_f32(UINT64_C(0x3db134a03e48836c)));
      arg2 = vcreate_f32(UINT64_C(0x3f1037713f18140a));
      clear_neon_saturated();
      //  Expect: "result" = 3d528a3c3dee3b743ee1fbf53ec61f8a
      result = vmulq_lane_f32(arg1, arg2, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 0);
         exp = ((float32_t) 0.38695937395095825);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 1);
         exp = ((float32_t) 0.44137540459632874);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 2);
         exp = ((float32_t) 0.11632433533668518);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 2 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 3);
         exp = ((float32_t) 5.140136182308197e-2);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 3 ", exp, got);
            }
      }
   }
}
}
void dotests_2535() {

{
   {
      float32x4_t arg1;
      float32x4_t arg2;
      float32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"mul_lane\", fnname = \"vmulq_laneq_f32\", rettype = \"float32x4_t\", argtypes = \"[float32x4_t,float32x4_t,__constrange(0,3) int]\", vals = [VectorVal [FloatVal 0.6252134442329407,FloatVal 0.842921793460846,FloatVal 0.8524498343467712,FloatVal 0.7536730170249939],VectorVal [FloatVal 0.6930545568466187,FloatVal 0.7800898551940918,FloatVal 0.6664859652519226,FloatVal 0.4535302519798279],IndexVal 2], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_f32(vcreate_f32(UINT64_C(0x3f57c9b93f200dfd)),
                          vcreate_f32(UINT64_C(0x3f40f0b73f5a3a27)));
      arg2 = vcombine_f32(vcreate_f32(UINT64_C(0x3f47b3f83f316c06)),
                          vcreate_f32(UINT64_C(0x3ee8351e3f2a9ed3)));
      clear_neon_saturated();
      //  Expect: "result" = 3f00978d3f1172023f0fd1d53ed5592d
      result = vmulq_laneq_f32(arg1, arg2, 2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 0);
         exp = ((float32_t) 0.4166959822177887);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 1);
         exp = ((float32_t) 0.5617955327033997);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 2);
         exp = ((float32_t) 0.5681458711624146);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 2 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 3);
         exp = ((float32_t) 0.5023124814033508);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 3 ", exp, got);
            }
      }
   }
}
}
void dotests_2536() {

{
   {
      float64x2_t arg1;
      float64x1_t arg2;
      float64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"mul_lane\", fnname = \"vmulq_lane_f64\", rettype = \"float64x2_t\", argtypes = \"[float64x2_t,float64x1_t,__constrange(0,0) int]\", vals = [VectorVal [FloatVal 0.4112910699821969,FloatVal 0.4988895519768657],VectorVal [FloatVal 0.7720997415691995],IndexVal 0], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_f64(vcreate_f64(UINT64_C(0x3fda5297c7ad76ea)),
                          vcreate_f64(UINT64_C(0x3fdfedce7183a178)));
      arg2 = vcreate_f64(UINT64_C(0x3fe8b50a846945be));
      clear_neon_saturated();
      //  Expect: "result" = 3fd8a6fe6b434a943fd452dda6fe3f36
      result = vmulq_lane_f64(arg1, arg2, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float64_t got;
         float64_t exp;
         got = vgetq_lane_f64(result, 0);
         exp = 0.31755772884297373;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float64_t got;
         float64_t exp;
         got = vgetq_lane_f64(result, 1);
         exp = 0.3851924941529117;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
   }
}
}
void dotests_2537() {

{
   {
      float64x2_t arg1;
      float64x2_t arg2;
      float64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"mul_lane\", fnname = \"vmulq_laneq_f64\", rettype = \"float64x2_t\", argtypes = \"[float64x2_t,float64x2_t,__constrange(0,1) int]\", vals = [VectorVal [FloatVal 0.3441351277958805,FloatVal 0.6895174614648224],VectorVal [FloatVal 0.5053415823387472,FloatVal 0.5335554128922732],IndexVal 0], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_f64(vcreate_f64(UINT64_C(0x3fd6064f57d27006)),
                          vcreate_f64(UINT64_C(0x3fe61086ec606531)));
      arg2 = vcombine_f64(vcreate_f64(UINT64_C(0x3fe02bc21c2e859d)),
                          vcreate_f64(UINT64_C(0x3fe112e2cd1f3c21)));
      clear_neon_saturated();
      //  Expect: "result" = 3fd64cdf063cae353fc6428b805b9355
      result = vmulq_laneq_f64(arg1, arg2, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float64_t got;
         float64_t exp;
         got = vgetq_lane_f64(result, 0);
         exp = 0.17390579001871723;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float64_t got;
         float64_t exp;
         got = vgetq_lane_f64(result, 1);
         exp = 0.34844184502682946;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
   }
}
}
void dotests_2538() {

{
   {
      uint16x8_t arg1;
      uint16x4_t arg2;
      uint16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"mul_lane\", fnname = \"vmulq_lane_u16\", rettype = \"uint16x8_t\", argtypes = \"[uint16x8_t,uint16x4_t,__constrange(0,3) int]\", vals = [VectorVal [IntegerVal 0,IntegerVal 65535,IntegerVal 65535,IntegerVal 32768,IntegerVal 0,IntegerVal 65535,IntegerVal 32767,IntegerVal 0],VectorVal [IntegerVal 54626,IntegerVal 65535,IntegerVal 0,IntegerVal 0],IndexVal 2], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u16(vcreate_u16(UINT64_C(0x8000ffffffff0000)),
                          vcreate_u16(UINT64_C(0x00007fffffff0000)));
      arg2 = vcreate_u16(UINT64_C(0x00000000ffffd562));
      clear_neon_saturated();
      //  Expect: "result" = 00000000000000000000000000000000
      result = vmulq_lane_u16(arg1, arg2, 2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 0);
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 1);
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2539() {

{
   {
      uint16x8_t arg1;
      uint16x8_t arg2;
      uint16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"mul_lane\", fnname = \"vmulq_laneq_u16\", rettype = \"uint16x8_t\", argtypes = \"[uint16x8_t,uint16x8_t,__constrange(0,7) int]\", vals = [VectorVal [IntegerVal 22612,IntegerVal 32767,IntegerVal 32767,IntegerVal 32767,IntegerVal 7873,IntegerVal 0,IntegerVal 60346,IntegerVal 65535],VectorVal [IntegerVal 945,IntegerVal 32767,IntegerVal 65535,IntegerVal 32768,IntegerVal 32767,IntegerVal 0,IntegerVal 32767,IntegerVal 48442],IndexVal 1], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u16(vcreate_u16(UINT64_C(0x7fff7fff7fff5854)),
                          vcreate_u16(UINT64_C(0xffffebba00001ec1)));
      arg2 = vcombine_u16(vcreate_u16(UINT64_C(0x8000ffff7fff03b1)),
                          vcreate_u16(UINT64_C(0xbd3a7fff00007fff)));
      clear_neon_saturated();
      //  Expect: "result" = 800114460000613f000100010001a7ac
      result = vmulq_laneq_u16(arg1, arg2, 1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 0);
         exp = UINT64_C(0x000100010001a7ac);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 1);
         exp = UINT64_C(0x800114460000613f);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2540() {

{
   {
      uint32x4_t arg1;
      uint32x2_t arg2;
      uint32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"mul_lane\", fnname = \"vmulq_lane_u32\", rettype = \"uint32x4_t\", argtypes = \"[uint32x4_t,uint32x2_t,__constrange(0,1) int]\", vals = [VectorVal [IntegerVal 2744025088,IntegerVal 32768,IntegerVal 4294967295,IntegerVal 0],VectorVal [IntegerVal 302612479,IntegerVal 3335875147],IndexVal 0], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u32(vcreate_u32(UINT64_C(0x00008000a38e8000)),
                          vcreate_u32(UINT64_C(0x00000000ffffffff)));
      arg2 = vcreate_u32(UINT64_C(0xc6d56a4b12097fff));
      clear_neon_saturated();
      //  Expect: "result" = 00000000edf68001bfff80001c718000
      result = vmulq_lane_u32(arg1, arg2, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 0);
         exp = UINT64_C(0xbfff80001c718000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 1);
         exp = UINT64_C(0x00000000edf68001);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2541() {

{
   {
      uint32x4_t arg1;
      uint32x4_t arg2;
      uint32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"mul_lane\", fnname = \"vmulq_laneq_u32\", rettype = \"uint32x4_t\", argtypes = \"[uint32x4_t,uint32x4_t,__constrange(0,3) int]\", vals = [VectorVal [IntegerVal 2147516415,IntegerVal 1250328575,IntegerVal 2147516415,IntegerVal 1499791360],VectorVal [IntegerVal 2147516415,IntegerVal 2605875200,IntegerVal 2147450879,IntegerVal 533626879],IndexVal 2], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u32(vcreate_u32(UINT64_C(0x4a867fff80007fff)),
                          vcreate_u32(UINT64_C(0x5965000080007fff)));
      arg2 = vcombine_u32(vcreate_u32(UINT64_C(0x9b52800080007fff)),
                          vcreate_u32(UINT64_C(0x1fce7fff7fff7fff)));
      clear_neon_saturated();
      //  Expect: "result" = 269b0000c0000001f57a0001c0000001
      result = vmulq_laneq_u32(arg1, arg2, 2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 0);
         exp = UINT64_C(0xf57a0001c0000001);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 1);
         exp = UINT64_C(0x269b0000c0000001);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2542() {

{
   {
      float32_t arg1;
      float32x2_t arg2;
      float32_t result;
      char* str1 = "ReproInfo2 {semantics = \"mul_lane\", fnname = \"vmuls_lane_f32\", rettype = \"float32_t\", argtypes = \"[float32_t,float32x2_t,__constrange(0,1) int]\", vals = [FloatVal 0.8467581272125244,VectorVal [FloatVal 0.949520468711853,FloatVal 0.3520168662071228],IndexVal 1], start_saturated = False}";
      int reported = 0;
      float32_t got;
      float32_t exp;
      arg1 = ((float32_t) 0.8467581272125244);
      arg2 = vcreate_f32(UINT64_C(0x3eb43b8e3f7313c6));
      clear_neon_saturated();
      //  Expect: "result" = 3e989d0b
      result = vmuls_lane_f32(arg1, arg2, 1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = ((float32_t) 0.2980731427669525);
      if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %f Got: %f\n", "   ", exp, got);
         }
   }
}
}
void dotests_2543() {

{
   {
      float32_t arg1;
      float32x4_t arg2;
      float32_t result;
      char* str1 = "ReproInfo2 {semantics = \"mul_lane\", fnname = \"vmuls_laneq_f32\", rettype = \"float32_t\", argtypes = \"[float32_t,float32x4_t,__constrange(0,3) int]\", vals = [FloatVal 0.2493545413017273,VectorVal [FloatVal 0.34476953744888306,FloatVal 0.920893669128418,FloatVal 0.5540589094161987,FloatVal 0.22351330518722534],IndexVal 1], start_saturated = False}";
      int reported = 0;
      float32_t got;
      float32_t exp;
      arg1 = ((float32_t) 0.2493545413017273);
      arg2 = vcombine_f32(vcreate_f32(UINT64_C(0x3f6bbfb03eb085a2)),
                          vcreate_f32(UINT64_C(0x3e64e0ac3f0dd6ce)));
      clear_neon_saturated();
      //  Expect: "result" = 3e6b23df
      result = vmuls_laneq_f32(arg1, arg2, 1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = ((float32_t) 0.2296290248632431);
      if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %f Got: %f\n", "   ", exp, got);
         }
   }
}
}
void dotests_2544() {

{
   {
      float64_t arg1;
      float64x1_t arg2;
      float64_t result;
      char* str1 = "ReproInfo2 {semantics = \"mul_lane\", fnname = \"vmuld_lane_f64\", rettype = \"float64_t\", argtypes = \"[float64_t,float64x1_t,__constrange(0,0) int]\", vals = [FloatVal 2.7442051436868953e-3,VectorVal [FloatVal 0.6378842323687585],IndexVal 0], start_saturated = False}";
      int reported = 0;
      float64_t got;
      float64_t exp;
      arg1 = 2.7442051436868953e-3;
      arg2 = vcreate_f64(UINT64_C(0x3fe4698c31950d5f));
      clear_neon_saturated();
      //  Expect: "result" = 3f5cae1129967c8e
      result = vmuld_lane_f64(arg1, arg2, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = 1.7504851915431138e-3;
      if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %f Got: %f\n", "   ", exp, got);
         }
   }
}
}
void dotests_2545() {

{
   {
      float64_t arg1;
      float64x2_t arg2;
      float64_t result;
      char* str1 = "ReproInfo2 {semantics = \"mul_lane\", fnname = \"vmuld_laneq_f64\", rettype = \"float64_t\", argtypes = \"[float64_t,float64x2_t,__constrange(0,1) int]\", vals = [FloatVal 0.7770991516689877,VectorVal [FloatVal 0.3899313518472808,FloatVal 0.6502644223504076],IndexVal 0], start_saturated = False}";
      int reported = 0;
      float64_t got;
      float64_t exp;
      arg1 = 0.7770991516689877;
      arg2 = vcombine_f64(vcreate_f64(UINT64_C(0x3fd8f4a2a0f79ffe)),
                          vcreate_f64(UINT64_C(0x3fe4cef75577ea25)));
      clear_neon_saturated();
      //  Expect: "result" = 3fd3649a6153e3fc
      result = vmuld_laneq_f64(arg1, arg2, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = 0.30301532272966347;
      if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %f Got: %f\n", "   ", exp, got);
         }
   }
}
}
void dotests_2546() {

{
   {
      float32x2_t arg1;
      float32x2_t arg2;
      float32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"mulx_lane\", fnname = \"vmulx_lane_f32\", rettype = \"float32x2_t\", argtypes = \"[float32x2_t,float32x2_t,__constrange(0,1) int]\", vals = [VectorVal [FloatVal 0.9557898044586182,FloatVal 0.40334004163742065],VectorVal [FloatVal 0.8063956499099731,FloatVal 0.5341342687606812],IndexVal 1], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_f32(UINT64_C(0x3ece82963f74aea4));
      arg2 = vcreate_f32(UINT64_C(0x3f08bd063f4e6ff2));
      clear_neon_saturated();
      //  Expect: "result" = 3e5c9bb63f02b172
      result = vmulx_lane_f32(arg1, arg2, 1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result, 0);
         exp = ((float32_t) 0.5105201005935669);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result, 1);
         exp = ((float32_t) 0.21543774008750916);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
   }
}
}
void dotests_2547() {

{
   {
      float32x2_t arg1;
      float32x4_t arg2;
      float32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"mulx_lane\", fnname = \"vmulx_laneq_f32\", rettype = \"float32x2_t\", argtypes = \"[float32x2_t,float32x4_t,__constrange(0,3) int]\", vals = [VectorVal [FloatVal 0.9881178140640259,FloatVal 0.8756234049797058],VectorVal [FloatVal 0.9952699542045593,FloatVal 0.34724175930023193,FloatVal 0.5058438181877136,FloatVal 0.6328058838844299],IndexVal 1], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_f32(UINT64_C(0x3f6028db3f7cf54a));
      arg2 = vcombine_f32(vcreate_f32(UINT64_C(0x3eb1c9ac3f7eca03)),
                          vcreate_f32(UINT64_C(0x3f21ff913f017efb)));
      clear_neon_saturated();
      //  Expect: "result" = 3e9bacd63eafacdf
      result = vmulx_laneq_f32(arg1, arg2, 1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result, 0);
         exp = ((float32_t) 0.34311577677726746);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result, 1);
         exp = ((float32_t) 0.30405300855636597);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
   }
}
}
void dotests_2548() {

{
   {
      float64x1_t arg1;
      float64x1_t arg2;
      float64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"mulx_lane\", fnname = \"vmulx_lane_f64\", rettype = \"float64x1_t\", argtypes = \"[float64x1_t,float64x1_t,__constrange(0,0) int]\", vals = [VectorVal [FloatVal 0.34782216364372665],VectorVal [FloatVal 0.176813880347087],IndexVal 0], start_saturated = False}";
      int reported = 0;
      float64_t got;
      float64_t exp;
      arg1 = vcreate_f64(UINT64_C(0x3fd642b7e46b1efc));
      arg2 = vcreate_f64(UINT64_C(0x3fc6a1d654c8e884));
      clear_neon_saturated();
      //  Expect: "result" = 3faf7ce666cf1a84
      result = vmulx_lane_f64(arg1, arg2, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_f64(result, 0);
      exp = 6.14997864245668e-2;
      if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
         }
   }
}
}
void dotests_2549() {

{
   {
      float64x1_t arg1;
      float64x2_t arg2;
      float64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"mulx_lane\", fnname = \"vmulx_laneq_f64\", rettype = \"float64x1_t\", argtypes = \"[float64x1_t,float64x2_t,__constrange(0,1) int]\", vals = [VectorVal [FloatVal 0.5144889180638196],VectorVal [FloatVal 0.8615764590280484,FloatVal 4.043675446396555e-2],IndexVal 0], start_saturated = False}";
      int reported = 0;
      float64_t got;
      float64_t exp;
      arg1 = vcreate_f64(UINT64_C(0x3fe076b176a7a207));
      arg2 = vcombine_f64(vcreate_f64(UINT64_C(0x3feb9208cb50ed2c)),
                          vcreate_f64(UINT64_C(0x3fa4b42053f54e70)));
      clear_neon_saturated();
      //  Expect: "result" = 3fdc5e8f9823877a
      result = vmulx_laneq_f64(arg1, arg2, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_f64(result, 0);
      exp = 0.44327154023459736;
      if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
         }
   }
}
}
void dotests_2550() {

{
   {
      float32x4_t arg1;
      float32x2_t arg2;
      float32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"mulx_lane\", fnname = \"vmulxq_lane_f32\", rettype = \"float32x4_t\", argtypes = \"[float32x4_t,float32x2_t,__constrange(0,1) int]\", vals = [VectorVal [FloatVal 0.4337705373764038,FloatVal 0.2165367603302002,FloatVal 0.9026340842247009,FloatVal 0.3564184904098511],VectorVal [FloatVal 0.1273057460784912,FloatVal 0.5605136752128601],IndexVal 1], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_f32(vcreate_f32(UINT64_C(0x3e5dbbd03ede172c)),
                          vcreate_f32(UINT64_C(0x3eb67c7c3f671307)));
      arg2 = vcreate_f32(UINT64_C(0x3f0f7dd33e025c70));
      clear_neon_saturated();
      //  Expect: "result" = 3e4c92753f0185343df891c93e78f834
      result = vmulxq_lane_f32(arg1, arg2, 1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 0);
         exp = ((float32_t) 0.24313431978225708);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 1);
         exp = ((float32_t) 0.1213718131184578);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 2);
         exp = ((float32_t) 0.5059387683868408);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 2 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 3);
         exp = ((float32_t) 0.19977743923664093);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 3 ", exp, got);
            }
      }
   }
}
}
void dotests_2551() {

{
   {
      float32x4_t arg1;
      float32x4_t arg2;
      float32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"mulx_lane\", fnname = \"vmulxq_laneq_f32\", rettype = \"float32x4_t\", argtypes = \"[float32x4_t,float32x4_t,__constrange(0,3) int]\", vals = [VectorVal [FloatVal 0.5485945343971252,FloatVal 0.19932204484939575,FloatVal 0.5820142030715942,FloatVal 0.8935727477073669],VectorVal [FloatVal 0.6694316267967224,FloatVal 0.5991485118865967,FloatVal 0.3231053948402405,FloatVal 0.46002107858657837],IndexVal 2], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_f32(vcreate_f32(UINT64_C(0x3e4c1b143f0c70b1)),
                          vcreate_f32(UINT64_C(0x3f64c12f3f14fee2)));
      arg2 = vcombine_f32(vcreate_f32(UINT64_C(0x3f1961cc3f2b5fdf)),
                          vcreate_f32(UINT64_C(0x3eeb87e23ea56e12)));
      clear_neon_saturated();
      //  Expect: "result" = 3e93d2de3e4090af3d83e5363e358209
      result = vmulxq_laneq_f32(arg1, arg2, 2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 0);
         exp = ((float32_t) 0.177253857254982);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 1);
         exp = ((float32_t) 6.44020289182663e-2);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 2);
         exp = ((float32_t) 0.18805192410945892);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 2 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 3);
         exp = ((float32_t) 0.28871816396713257);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 3 ", exp, got);
            }
      }
   }
}
}
void dotests_2552() {

{
   {
      float64x2_t arg1;
      float64x1_t arg2;
      float64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"mulx_lane\", fnname = \"vmulxq_lane_f64\", rettype = \"float64x2_t\", argtypes = \"[float64x2_t,float64x1_t,__constrange(0,0) int]\", vals = [VectorVal [FloatVal 0.18233473463637406,FloatVal 0.38374367007481125],VectorVal [FloatVal 8.751733221658142e-2],IndexVal 0], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_f64(vcreate_f64(UINT64_C(0x3fc756be9d181284)),
                          vcreate_f64(UINT64_C(0x3fd88f419c412c4a)));
      arg2 = vcreate_f64(UINT64_C(0x3fb667892fb41100));
      clear_neon_saturated();
      //  Expect: "result" = 3fa131f38089406b3f9057264fb4ff12
      result = vmulxq_lane_f64(arg1, arg2, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float64_t got;
         float64_t exp;
         got = vgetq_lane_f64(result, 0);
         exp = 1.5957449545793763e-2;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float64_t got;
         float64_t exp;
         got = vgetq_lane_f64(result, 1);
         exp = 3.358422225994747e-2;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
   }
}
}
void dotests_2553() {

{
   {
      float64x2_t arg1;
      float64x2_t arg2;
      float64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"mulx_lane\", fnname = \"vmulxq_laneq_f64\", rettype = \"float64x2_t\", argtypes = \"[float64x2_t,float64x2_t,__constrange(0,1) int]\", vals = [VectorVal [FloatVal 0.5324069475834158,FloatVal 0.11566246687807136],VectorVal [FloatVal 1.394480943102716e-2,FloatVal 0.4842785867874453],IndexVal 1], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_f64(vcreate_f64(UINT64_C(0x3fe1097a4b81162d)),
                          vcreate_f64(UINT64_C(0x3fbd9c0e309db228)));
      arg2 = vcombine_f64(vcreate_f64(UINT64_C(0x3f8c8f18a3a44740)),
                          vcreate_f64(UINT64_C(0x3fdefe6b9d19ee64)));
      clear_neon_saturated();
      //  Expect: "result" = 3facadb79162d16a3fd080572cd59038
      result = vmulxq_laneq_f64(arg1, arg2, 1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float64_t got;
         float64_t exp;
         got = vgetq_lane_f64(result, 0);
         exp = 0.2578332841715141;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float64_t got;
         float64_t exp;
         got = vgetq_lane_f64(result, 1);
         exp = 5.60128560040621e-2;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
   }
}
}
void dotests_2554() {

{
   {
      float32_t arg1;
      float32x2_t arg2;
      float32_t result;
      char* str1 = "ReproInfo2 {semantics = \"mulx_lane\", fnname = \"vmulxs_lane_f32\", rettype = \"float32_t\", argtypes = \"[float32_t,float32x2_t,__constrange(0,1) int]\", vals = [FloatVal 0.8174406290054321,VectorVal [FloatVal 0.7464399337768555,FloatVal 8.797574043273926e-2],IndexVal 1], start_saturated = False}";
      int reported = 0;
      float32_t got;
      float32_t exp;
      arg1 = ((float32_t) 0.8174406290054321);
      arg2 = vcreate_f32(UINT64_C(0x3db42ca03f3f16b0));
      clear_neon_saturated();
      //  Expect: "result" = 3d934824
      result = vmulxs_lane_f32(arg1, arg2, 1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = ((float32_t) 7.191494107246399e-2);
      if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %f Got: %f\n", "   ", exp, got);
         }
   }
}
}
void dotests_2555() {

{
   {
      float32_t arg1;
      float32x4_t arg2;
      float32_t result;
      char* str1 = "ReproInfo2 {semantics = \"mulx_lane\", fnname = \"vmulxs_laneq_f32\", rettype = \"float32_t\", argtypes = \"[float32_t,float32x4_t,__constrange(0,3) int]\", vals = [FloatVal 3.0149400234222412e-2,VectorVal [FloatVal 0.10499167442321777,FloatVal 0.8034687638282776,FloatVal 0.4679054021835327,FloatVal 0.7265107035636902],IndexVal 1], start_saturated = False}";
      int reported = 0;
      float32_t got;
      float32_t exp;
      arg1 = ((float32_t) 3.0149400234222412e-2);
      arg2 = vcombine_f32(vcreate_f32(UINT64_C(0x3f4db0213dd705e0)),
                          vcreate_f32(UINT64_C(0x3f39fc9b3eef914c)));
      clear_neon_saturated();
      //  Expect: "result" = 3cc6719f
      result = vmulxs_laneq_f32(arg1, arg2, 1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = ((float32_t) 2.422410063445568e-2);
      if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %f Got: %f\n", "   ", exp, got);
         }
   }
}
}
void dotests_2556() {

{
   {
      float64_t arg1;
      float64x1_t arg2;
      float64_t result;
      char* str1 = "ReproInfo2 {semantics = \"mulx_lane\", fnname = \"vmulxd_lane_f64\", rettype = \"float64_t\", argtypes = \"[float64_t,float64x1_t,__constrange(0,0) int]\", vals = [FloatVal 6.256700356570433e-2,VectorVal [FloatVal 0.34734595876778285],IndexVal 0], start_saturated = False}";
      int reported = 0;
      float64_t got;
      float64_t exp;
      arg1 = 6.256700356570433e-2;
      arg2 = vcreate_f64(UINT64_C(0x3fd63aea8b538b8a));
      clear_neon_saturated();
      //  Expect: "result" = 3f96410465995f2d
      result = vmulxd_lane_f64(arg1, arg2, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = 2.1732395840756858e-2;
      if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %f Got: %f\n", "   ", exp, got);
         }
   }
}
}
void dotests_2557() {

{
   {
      float64_t arg1;
      float64x2_t arg2;
      float64_t result;
      char* str1 = "ReproInfo2 {semantics = \"mulx_lane\", fnname = \"vmulxd_laneq_f64\", rettype = \"float64_t\", argtypes = \"[float64_t,float64x2_t,__constrange(0,1) int]\", vals = [FloatVal 0.8801503178254637,VectorVal [FloatVal 0.5755193021089153,FloatVal 0.3996066246782778],IndexVal 0], start_saturated = False}";
      int reported = 0;
      float64_t got;
      float64_t exp;
      arg1 = 0.8801503178254637;
      arg2 = vcombine_f64(vcreate_f64(UINT64_C(0x3fe26aa77498c8fe)),
                          vcreate_f64(UINT64_C(0x3fd99327aa108586)));
      clear_neon_saturated();
      //  Expect: "result" = 3fe0359ab505cd54
      result = vmulxd_laneq_f64(arg1, arg2, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = 0.5065434966658509;
      if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %f Got: %f\n", "   ", exp, got);
         }
   }
}
}
void dotests_2558() {

{
   {
      int8x8_t arg1;
      int8x8_t arg2;
      int8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"ext8\", fnname = \"vext_s8\", rettype = \"int8x8_t\", argtypes = \"[int8x8_t,int8x8_t,__constrange(0,7) int]\", vals = [VectorVal [IntegerVal 98,IntegerVal 127,IntegerVal (-1),IntegerVal 127,IntegerVal 127,IntegerVal 0,IntegerVal (-128),IntegerVal (-83)],VectorVal [IntegerVal 127,IntegerVal (-1),IntegerVal (-128),IntegerVal 0,IntegerVal (-1),IntegerVal (-128),IntegerVal 127,IntegerVal (-128)],IndexVal 2], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s8(UINT64_C(0xad80007f7fff7f62));
      arg2 = vcreate_s8(UINT64_C(0x807f80ff0080ff7f));
      clear_neon_saturated();
      //  Expect: "result" = ff7fad80007f7fff
      result = vext_s8(arg1, arg2, 2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s8(result), 0);
      exp = UINT64_C(0xff7fad80007f7fff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2559() {

{
   {
      uint8x8_t arg1;
      uint8x8_t arg2;
      uint8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"ext8\", fnname = \"vext_u8\", rettype = \"uint8x8_t\", argtypes = \"[uint8x8_t,uint8x8_t,__constrange(0,7) int]\", vals = [VectorVal [IntegerVal 255,IntegerVal 128,IntegerVal 127,IntegerVal 127,IntegerVal 127,IntegerVal 0,IntegerVal 26,IntegerVal 0],VectorVal [IntegerVal 128,IntegerVal 127,IntegerVal 76,IntegerVal 255,IntegerVal 225,IntegerVal 127,IntegerVal 255,IntegerVal 0],IndexVal 7], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u8(UINT64_C(0x001a007f7f7f80ff));
      arg2 = vcreate_u8(UINT64_C(0x00ff7fe1ff4c7f80));
      clear_neon_saturated();
      //  Expect: "result" = ff7fe1ff4c7f8000
      result = vext_u8(arg1, arg2, 7);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u8(result), 0);
      exp = UINT64_C(0xff7fe1ff4c7f8000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2560() {

{
   {
      poly8x8_t arg1;
      poly8x8_t arg2;
      poly8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"ext8\", fnname = \"vext_p8\", rettype = \"poly8x8_t\", argtypes = \"[poly8x8_t,poly8x8_t,__constrange(0,7) int]\", vals = [VectorVal [PolyVal [0,1,1,0,1,1,0,1],PolyVal [0,0,1,1,0,1,0,0],PolyVal [0,1,1,0,1,0,1,1],PolyVal [1,0,1,1,0,0,1,0],PolyVal [0,0,1,1,0,0,0,1],PolyVal [1,0,1,0,1,1,1,0],PolyVal [0,1,0,1,0,0,0,1],PolyVal [1,0,0,1,1,1,1,1]],VectorVal [PolyVal [0,0,0,0,0,0,0,1],PolyVal [1,0,0,0,0,1,1,1],PolyVal [0,0,1,1,0,1,1,1],PolyVal [0,0,1,0,1,0,1,1],PolyVal [1,0,0,1,1,0,1,1],PolyVal [0,1,1,0,1,0,1,0],PolyVal [0,0,0,0,1,0,0,0],PolyVal [0,0,0,0,0,0,0,1]],IndexVal 7], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_p8(UINT64_C(0xf98a758c4dd62cb6));
      arg2 = vcreate_p8(UINT64_C(0x801056d9d4ece180));
      clear_neon_saturated();
      //  Expect: "result" = 1056d9d4ece180f9
      result = vext_p8(arg1, arg2, 7);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_p8(result), 0);
      exp = UINT64_C(0x1056d9d4ece180f9);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2561() {

{
   {
      int16x4_t arg1;
      int16x4_t arg2;
      int16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"ext16\", fnname = \"vext_s16\", rettype = \"int16x4_t\", argtypes = \"[int16x4_t,int16x4_t,__constrange(0,3) int]\", vals = [VectorVal [IntegerVal (-32768),IntegerVal 32767,IntegerVal 0,IntegerVal (-7097)],VectorVal [IntegerVal (-1),IntegerVal (-32768),IntegerVal (-32768),IntegerVal 18635],IndexVal 1], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s16(UINT64_C(0xe44700007fff8000));
      arg2 = vcreate_s16(UINT64_C(0x48cb80008000ffff));
      clear_neon_saturated();
      //  Expect: "result" = ffffe44700007fff
      result = vext_s16(arg1, arg2, 1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s16(result), 0);
      exp = UINT64_C(0xffffe44700007fff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2562() {

{
   {
      uint16x4_t arg1;
      uint16x4_t arg2;
      uint16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"ext16\", fnname = \"vext_u16\", rettype = \"uint16x4_t\", argtypes = \"[uint16x4_t,uint16x4_t,__constrange(0,3) int]\", vals = [VectorVal [IntegerVal 32768,IntegerVal 32767,IntegerVal 32768,IntegerVal 32767],VectorVal [IntegerVal 65535,IntegerVal 17330,IntegerVal 65535,IntegerVal 32767],IndexVal 0], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u16(UINT64_C(0x7fff80007fff8000));
      arg2 = vcreate_u16(UINT64_C(0x7fffffff43b2ffff));
      clear_neon_saturated();
      //  Expect: "result" = 7fff80007fff8000
      result = vext_u16(arg1, arg2, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u16(result), 0);
      exp = UINT64_C(0x7fff80007fff8000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2563() {

{
   {
      poly16x4_t arg1;
      poly16x4_t arg2;
      poly16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"ext16\", fnname = \"vext_p16\", rettype = \"poly16x4_t\", argtypes = \"[poly16x4_t,poly16x4_t,__constrange(0,3) int]\", vals = [VectorVal [PolyVal [1,0,1,1,0,0,1,1,0,0,0,1,0,0,1,0],PolyVal [1,1,1,1,0,1,1,1,1,1,0,0,1,0,0,0],PolyVal [0,1,0,0,1,0,0,1,0,1,0,0,1,0,0,0],PolyVal [0,1,0,0,0,0,1,0,1,1,0,1,1,1,0,0]],VectorVal [PolyVal [0,1,0,0,0,0,1,0,0,0,0,0,0,1,1,0],PolyVal [1,1,0,1,1,0,1,0,0,0,1,1,0,0,1,1],PolyVal [0,1,1,1,0,0,1,1,0,1,1,1,0,0,0,0],PolyVal [0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1]],IndexVal 1], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_p16(UINT64_C(0x3b42129213ef48cd));
      arg2 = vcreate_p16(UINT64_C(0x80120ececc5b6042));
      clear_neon_saturated();
      //  Expect: "result" = 60423b42129213ef
      result = vext_p16(arg1, arg2, 1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_p16(result), 0);
      exp = UINT64_C(0x60423b42129213ef);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2564() {

{
   {
      int32x2_t arg1;
      int32x2_t arg2;
      int32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"ext32\", fnname = \"vext_s32\", rettype = \"int32x2_t\", argtypes = \"[int32x2_t,int32x2_t,__constrange(0,1) int]\", vals = [VectorVal [IntegerVal (-2147483648),IntegerVal (-2017820672)],VectorVal [IntegerVal (-2147418113),IntegerVal 38356],IndexVal 1], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s32(UINT64_C(0x87ba800080000000));
      arg2 = vcreate_s32(UINT64_C(0x000095d48000ffff));
      clear_neon_saturated();
      //  Expect: "result" = 8000ffff87ba8000
      result = vext_s32(arg1, arg2, 1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s32(result), 0);
      exp = UINT64_C(0x8000ffff87ba8000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2565() {

{
   {
      uint32x2_t arg1;
      uint32x2_t arg2;
      uint32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"ext32\", fnname = \"vext_u32\", rettype = \"uint32x2_t\", argtypes = \"[uint32x2_t,uint32x2_t,__constrange(0,1) int]\", vals = [VectorVal [IntegerVal 65535,IntegerVal 32767],VectorVal [IntegerVal 4137383977,IntegerVal 908544108],IndexVal 1], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u32(UINT64_C(0x00007fff0000ffff));
      arg2 = vcreate_u32(UINT64_C(0x3627486cf69b7829));
      clear_neon_saturated();
      //  Expect: "result" = f69b782900007fff
      result = vext_u32(arg1, arg2, 1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u32(result), 0);
      exp = UINT64_C(0xf69b782900007fff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2566() {

{
   {
      float32x2_t arg1;
      float32x2_t arg2;
      float32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"ext32\", fnname = \"vext_f32\", rettype = \"float32x2_t\", argtypes = \"[float32x2_t,float32x2_t,__constrange(0,1) int]\", vals = [VectorVal [FloatVal 0.6486192345619202,FloatVal 0.25870752334594727],VectorVal [FloatVal 0.14252448081970215,FloatVal 0.14852386713027954],IndexVal 0], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_f32(UINT64_C(0x3e8475503f260be9));
      arg2 = vcreate_f32(UINT64_C(0x3e1816a43e11f1f0));
      clear_neon_saturated();
      //  Expect: "result" = 3e8475503f260be9
      result = vext_f32(arg1, arg2, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result, 0);
         exp = ((float32_t) 0.6486192345619202);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result, 1);
         exp = ((float32_t) 0.25870752334594727);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
   }
}
}
void dotests_2567() {

{
   {
      int64x1_t arg1;
      int64x1_t arg2;
      int64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"ext64\", fnname = \"vext_s64\", rettype = \"int64x1_t\", argtypes = \"[int64x1_t,int64x1_t,__constrange(0,0) int]\", vals = [VectorVal [IntegerVal 9223231299710833338],VectorVal [IntegerVal 9223335611237171199],IndexVal 0], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s64(UINT64_C(0x7fff8000148752ba));
      arg2 = vcreate_s64(UINT64_C(0x7fffdedf00007fff));
      clear_neon_saturated();
      //  Expect: "result" = 7fff8000148752ba
      result = vext_s64(arg1, arg2, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s64(result), 0);
      exp = UINT64_C(0x7fff8000148752ba);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2568() {

{
   {
      uint64x1_t arg1;
      uint64x1_t arg2;
      uint64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"ext64\", fnname = \"vext_u64\", rettype = \"uint64x1_t\", argtypes = \"[uint64x1_t,uint64x1_t,__constrange(0,0) int]\", vals = [VectorVal [IntegerVal 9223090563950641152],VectorVal [IntegerVal 9223512772195647487],IndexVal 0], start_saturated = True}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u64(UINT64_C(0x7fff00007b890000));
      arg2 = vcreate_u64(UINT64_C(0x80007fff7fffffff));
      set_neon_saturated();
      //  Expect: "result" = 7fff00007b890000
      result = vext_u64(arg1, arg2, 0);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      got = vget_lane_u64(result, 0);
      exp = UINT64_C(0x7fff00007b890000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2569() {

{
   {
      int8x16_t arg1;
      int8x16_t arg2;
      int8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"ext8\", fnname = \"vextq_s8\", rettype = \"int8x16_t\", argtypes = \"[int8x16_t,int8x16_t,__constrange(0,15) int]\", vals = [VectorVal [IntegerVal (-1),IntegerVal (-1),IntegerVal (-128),IntegerVal (-1),IntegerVal (-1),IntegerVal 0,IntegerVal (-128),IntegerVal (-1),IntegerVal (-128),IntegerVal 0,IntegerVal (-128),IntegerVal 0,IntegerVal (-1),IntegerVal (-1),IntegerVal 127,IntegerVal 127],VectorVal [IntegerVal 127,IntegerVal (-1),IntegerVal 127,IntegerVal (-128),IntegerVal 127,IntegerVal 0,IntegerVal (-1),IntegerVal (-128),IntegerVal (-94),IntegerVal (-128),IntegerVal (-128),IntegerVal (-128),IntegerVal 82,IntegerVal (-87),IntegerVal 0,IntegerVal (-1)],IndexVal 14], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s8(vcreate_s8(UINT64_C(0xff8000ffff80ffff)),
                         vcreate_s8(UINT64_C(0x7f7fffff00800080)));
      arg2 = vcombine_s8(vcreate_s8(UINT64_C(0x80ff007f807fff7f)),
                         vcreate_s8(UINT64_C(0xff00a952808080a2)));
      clear_neon_saturated();
      //  Expect: "result" = a952808080a280ff007f807fff7f7f7f
      result = vextq_s8(arg1, arg2, 14);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result), 0);
         exp = UINT64_C(0x007f807fff7f7f7f);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result), 1);
         exp = UINT64_C(0xa952808080a280ff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2570() {

{
   {
      uint8x16_t arg1;
      uint8x16_t arg2;
      uint8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"ext8\", fnname = \"vextq_u8\", rettype = \"uint8x16_t\", argtypes = \"[uint8x16_t,uint8x16_t,__constrange(0,15) int]\", vals = [VectorVal [IntegerVal 255,IntegerVal 0,IntegerVal 128,IntegerVal 0,IntegerVal 118,IntegerVal 255,IntegerVal 128,IntegerVal 128,IntegerVal 128,IntegerVal 80,IntegerVal 128,IntegerVal 128,IntegerVal 225,IntegerVal 128,IntegerVal 41,IntegerVal 128],VectorVal [IntegerVal 127,IntegerVal 0,IntegerVal 0,IntegerVal 255,IntegerVal 255,IntegerVal 71,IntegerVal 255,IntegerVal 255,IntegerVal 170,IntegerVal 0,IntegerVal 128,IntegerVal 127,IntegerVal 255,IntegerVal 0,IntegerVal 0,IntegerVal 128],IndexVal 13], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u8(vcreate_u8(UINT64_C(0x8080ff76008000ff)),
                         vcreate_u8(UINT64_C(0x802980e180805080)));
      arg2 = vcombine_u8(vcreate_u8(UINT64_C(0xffff47ffff00007f)),
                         vcreate_u8(UINT64_C(0x800000ff7f8000aa)));
      clear_neon_saturated();
      //  Expect: "result" = ff7f8000aaffff47ffff00007f802980
      result = vextq_u8(arg1, arg2, 13);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 0);
         exp = UINT64_C(0xffff00007f802980);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 1);
         exp = UINT64_C(0xff7f8000aaffff47);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2571() {

{
   {
      poly8x16_t arg1;
      poly8x16_t arg2;
      poly8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"ext8\", fnname = \"vextq_p8\", rettype = \"poly8x16_t\", argtypes = \"[poly8x16_t,poly8x16_t,__constrange(0,15) int]\", vals = [VectorVal [PolyVal [1,1,1,0,1,1,1,0],PolyVal [1,1,1,1,0,1,0,1],PolyVal [0,1,1,0,1,1,1,1],PolyVal [1,0,1,1,1,0,0,0],PolyVal [1,1,1,1,0,0,1,1],PolyVal [0,0,1,1,0,1,0,0],PolyVal [0,0,0,0,0,1,0,0],PolyVal [1,1,0,0,0,0,0,0],PolyVal [1,0,0,0,0,0,1,0],PolyVal [0,1,0,0,1,1,1,0],PolyVal [0,0,0,0,0,0,1,1],PolyVal [0,0,1,0,0,1,1,0],PolyVal [0,0,1,1,1,1,1,1],PolyVal [1,1,0,1,1,0,1,1],PolyVal [0,0,0,0,0,1,1,1],PolyVal [1,0,1,1,0,0,0,1]],VectorVal [PolyVal [1,0,0,1,1,0,0,0],PolyVal [1,0,1,0,0,0,0,1],PolyVal [0,1,1,1,0,1,0,0],PolyVal [1,0,0,0,0,0,1,1],PolyVal [0,0,0,0,1,1,1,0],PolyVal [1,0,1,1,1,1,0,1],PolyVal [0,0,0,0,0,0,1,1],PolyVal [0,1,1,0,1,1,1,0],PolyVal [1,1,0,0,1,1,0,0],PolyVal [1,0,0,0,1,1,1,0],PolyVal [0,1,1,0,0,0,0,1],PolyVal [0,0,1,0,0,0,1,1],PolyVal [0,1,0,0,1,0,1,0],PolyVal [1,0,0,1,0,0,0,1],PolyVal [0,1,0,0,1,0,0,0],PolyVal [0,1,0,0,1,0,0,1]],IndexVal 2], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_p8(vcreate_p8(UINT64_C(0x03202ccf1df6af77)),
                         vcreate_p8(UINT64_C(0x8de0dbfc64c07241)));
      arg2 = vcombine_p8(vcreate_p8(UINT64_C(0x76c0bd70c12e8519)),
                         vcreate_p8(UINT64_C(0x92128952c4867133)));
      clear_neon_saturated();
      //  Expect: "result" = 85198de0dbfc64c0724103202ccf1df6
      result = vextq_p8(arg1, arg2, 2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p8(result), 0);
         exp = UINT64_C(0x724103202ccf1df6);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p8(result), 1);
         exp = UINT64_C(0x85198de0dbfc64c0);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2572() {

{
   {
      int16x8_t arg1;
      int16x8_t arg2;
      int16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"ext16\", fnname = \"vextq_s16\", rettype = \"int16x8_t\", argtypes = \"[int16x8_t,int16x8_t,__constrange(0,7) int]\", vals = [VectorVal [IntegerVal 0,IntegerVal 32767,IntegerVal (-5847),IntegerVal (-1),IntegerVal (-32768),IntegerVal (-1),IntegerVal (-32768),IntegerVal 32767],VectorVal [IntegerVal 22036,IntegerVal 32767,IntegerVal (-12884),IntegerVal (-32768),IntegerVal (-32768),IntegerVal 22641,IntegerVal (-32768),IntegerVal 0],IndexVal 4], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s16(vcreate_s16(UINT64_C(0xffffe9297fff0000)),
                          vcreate_s16(UINT64_C(0x7fff8000ffff8000)));
      arg2 = vcombine_s16(vcreate_s16(UINT64_C(0x8000cdac7fff5614)),
                          vcreate_s16(UINT64_C(0x0000800058718000)));
      clear_neon_saturated();
      //  Expect: "result" = 8000cdac7fff56147fff8000ffff8000
      result = vextq_s16(arg1, arg2, 4);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 0);
         exp = UINT64_C(0x7fff8000ffff8000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 1);
         exp = UINT64_C(0x8000cdac7fff5614);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2573() {

{
   {
      uint16x8_t arg1;
      uint16x8_t arg2;
      uint16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"ext16\", fnname = \"vextq_u16\", rettype = \"uint16x8_t\", argtypes = \"[uint16x8_t,uint16x8_t,__constrange(0,7) int]\", vals = [VectorVal [IntegerVal 32768,IntegerVal 31633,IntegerVal 32768,IntegerVal 0,IntegerVal 32768,IntegerVal 0,IntegerVal 32767,IntegerVal 20370],VectorVal [IntegerVal 65535,IntegerVal 32767,IntegerVal 32992,IntegerVal 61213,IntegerVal 56108,IntegerVal 32767,IntegerVal 32767,IntegerVal 0],IndexVal 7], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u16(vcreate_u16(UINT64_C(0x000080007b918000)),
                          vcreate_u16(UINT64_C(0x4f927fff00008000)));
      arg2 = vcombine_u16(vcreate_u16(UINT64_C(0xef1d80e07fffffff)),
                          vcreate_u16(UINT64_C(0x00007fff7fffdb2c)));
      clear_neon_saturated();
      //  Expect: "result" = 7fff7fffdb2cef1d80e07fffffff4f92
      result = vextq_u16(arg1, arg2, 7);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 0);
         exp = UINT64_C(0x80e07fffffff4f92);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 1);
         exp = UINT64_C(0x7fff7fffdb2cef1d);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2574() {

{
   {
      poly16x8_t arg1;
      poly16x8_t arg2;
      poly16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"ext16\", fnname = \"vextq_p16\", rettype = \"poly16x8_t\", argtypes = \"[poly16x8_t,poly16x8_t,__constrange(0,7) int]\", vals = [VectorVal [PolyVal [0,0,0,0,0,1,1,1,0,1,0,0,1,1,1,0],PolyVal [1,1,1,1,0,1,1,0,0,1,1,0,0,1,1,0],PolyVal [0,1,1,0,1,1,1,0,1,0,1,0,1,1,0,1],PolyVal [1,1,1,1,1,1,0,0,0,0,1,0,1,0,1,1],PolyVal [1,0,0,1,1,1,0,1,0,0,1,1,1,1,0,1],PolyVal [1,0,1,1,1,1,1,0,0,1,0,0,0,0,1,1],PolyVal [1,1,1,0,0,1,0,1,1,0,0,0,0,0,0,1],PolyVal [0,1,1,0,0,0,1,0,0,0,1,1,1,1,0,1]],VectorVal [PolyVal [1,0,0,1,1,1,0,1,0,1,1,1,1,1,0,1],PolyVal [0,0,0,0,1,0,0,1,1,0,1,1,1,1,1,0],PolyVal [0,1,0,0,1,1,1,1,1,1,0,0,1,1,1,0],PolyVal [1,1,1,1,1,0,1,0,0,1,1,1,0,0,1,0],PolyVal [1,0,1,1,0,1,0,0,1,1,0,1,0,0,0,1],PolyVal [0,0,0,0,1,1,0,1,0,1,1,1,1,1,0,1],PolyVal [0,1,0,0,0,1,1,1,1,1,0,1,0,0,1,0],PolyVal [1,1,0,1,0,1,0,0,0,0,1,1,1,0,1,1]],IndexVal 7], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_p16(vcreate_p16(UINT64_C(0xd43fb576666f72e0)),
                          vcreate_p16(UINT64_C(0xbc4681a7c27dbcb9)));
      arg2 = vcombine_p16(vcreate_p16(UINT64_C(0x4e5f73f27d90beb9)),
                          vcreate_p16(UINT64_C(0xdc2b4be2beb08b2d)));
      clear_neon_saturated();
      //  Expect: "result" = 4be2beb08b2d4e5f73f27d90beb9bc46
      result = vextq_p16(arg1, arg2, 7);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p16(result), 0);
         exp = UINT64_C(0x73f27d90beb9bc46);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p16(result), 1);
         exp = UINT64_C(0x4be2beb08b2d4e5f);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2575() {

{
   {
      int32x4_t arg1;
      int32x4_t arg2;
      int32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"ext32\", fnname = \"vextq_s32\", rettype = \"int32x4_t\", argtypes = \"[int32x4_t,int32x4_t,__constrange(0,3) int]\", vals = [VectorVal [IntegerVal (-29256),IntegerVal 32768,IntegerVal (-2147450880),IntegerVal 0],VectorVal [IntegerVal (-728),IntegerVal (-32769),IntegerVal 32768,IntegerVal 1985052671],IndexVal 0], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s32(vcreate_s32(UINT64_C(0x00008000ffff8db8)),
                          vcreate_s32(UINT64_C(0x0000000080008000)));
      arg2 = vcombine_s32(vcreate_s32(UINT64_C(0xffff7ffffffffd28)),
                          vcreate_s32(UINT64_C(0x76517fff00008000)));
      clear_neon_saturated();
      //  Expect: "result" = 000000008000800000008000ffff8db8
      result = vextq_s32(arg1, arg2, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 0);
         exp = UINT64_C(0x00008000ffff8db8);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 1);
         exp = UINT64_C(0x0000000080008000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2576() {

{
   {
      uint32x4_t arg1;
      uint32x4_t arg2;
      uint32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"ext32\", fnname = \"vextq_u32\", rettype = \"uint32x4_t\", argtypes = \"[uint32x4_t,uint32x4_t,__constrange(0,3) int]\", vals = [VectorVal [IntegerVal 2824273919,IntegerVal 4045242368,IntegerVal 2147483648,IntegerVal 2147450880],VectorVal [IntegerVal 757366783,IntegerVal 32767,IntegerVal 2147483648,IntegerVal 4294934528],IndexVal 1], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u32(vcreate_u32(UINT64_C(0xf11d8000a856ffff)),
                          vcreate_u32(UINT64_C(0x7fff800080000000)));
      arg2 = vcombine_u32(vcreate_u32(UINT64_C(0x00007fff2d247fff)),
                          vcreate_u32(UINT64_C(0xffff800080000000)));
      clear_neon_saturated();
      //  Expect: "result" = 2d247fff7fff800080000000f11d8000
      result = vextq_u32(arg1, arg2, 1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 0);
         exp = UINT64_C(0x80000000f11d8000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 1);
         exp = UINT64_C(0x2d247fff7fff8000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2577() {

{
   {
      float32x4_t arg1;
      float32x4_t arg2;
      float32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"ext32\", fnname = \"vextq_f32\", rettype = \"float32x4_t\", argtypes = \"[float32x4_t,float32x4_t,__constrange(0,3) int]\", vals = [VectorVal [FloatVal 5.060476064682007e-2,FloatVal 0.3363058567047119,FloatVal 0.4013800024986267,FloatVal 0.6194342374801636],VectorVal [FloatVal 0.47316646575927734,FloatVal 0.6041872501373291,FloatVal 0.8394735455513,FloatVal 0.4224017858505249],IndexVal 3], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_f32(vcreate_f32(UINT64_C(0x3eac30483d4f46f0)),
                          vcreate_f32(UINT64_C(0x3f1e933e3ecd81ae)));
      arg2 = vcombine_f32(vcreate_f32(UINT64_C(0x3f1aac043ef242e0)),
                          vcreate_f32(UINT64_C(0x3ed8450c3f56e7bd)));
      clear_neon_saturated();
      //  Expect: "result" = 3f56e7bd3f1aac043ef242e03f1e933e
      result = vextq_f32(arg1, arg2, 3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 0);
         exp = ((float32_t) 0.6194342374801636);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 1);
         exp = ((float32_t) 0.47316646575927734);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 2);
         exp = ((float32_t) 0.6041872501373291);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 2 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 3);
         exp = ((float32_t) 0.8394735455513);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 3 ", exp, got);
            }
      }
   }
}
}
void dotests_2578() {

{
   {
      int64x2_t arg1;
      int64x2_t arg2;
      int64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"ext64\", fnname = \"vextq_s64\", rettype = \"int64x2_t\", argtypes = \"[int64x2_t,int64x2_t,__constrange(0,1) int]\", vals = [VectorVal [IntegerVal 9223372036854743039,IntegerVal (-140739635865557)],VectorVal [IntegerVal (-6529093560174247936),IntegerVal 9223230408160726839],IndexVal 1], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s64(vcreate_s64(UINT64_C(0x7fffffffffff7fff)),
                          vcreate_s64(UINT64_C(0xffff7fff7fff982b)));
      arg2 = vcombine_s64(vcreate_s64(UINT64_C(0xa563ffffe8860000)),
                          vcreate_s64(UINT64_C(0x7fff7f3080004f37)));
      clear_neon_saturated();
      //  Expect: "result" = a563ffffe8860000ffff7fff7fff982b
      result = vextq_s64(arg1, arg2, 1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 0);
         exp = UINT64_C(0xffff7fff7fff982b);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 1);
         exp = UINT64_C(0xa563ffffe8860000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2579() {

{
   {
      uint64x2_t arg1;
      uint64x2_t arg2;
      uint64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"ext64\", fnname = \"vextq_u64\", rettype = \"uint64x2_t\", argtypes = \"[uint64x2_t,uint64x2_t,__constrange(0,1) int]\", vals = [VectorVal [IntegerVal 9223372032559808512,IntegerVal 140737441595391],VectorVal [IntegerVal 18446603331926261760,IntegerVal 18446551807351080573],IndexVal 1], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u64(vcreate_u64(UINT64_C(0x7fffffff00000000)),
                          vcreate_u64(UINT64_C(0x00007ffffd367fff)));
      arg2 = vcombine_u64(vcreate_u64(UINT64_C(0xffff7fff00008000)),
                          vcreate_u64(UINT64_C(0xffff51228000467d)));
      clear_neon_saturated();
      //  Expect: "result" = ffff7fff0000800000007ffffd367fff
      result = vextq_u64(arg1, arg2, 1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 0);
         exp = UINT64_C(0x00007ffffd367fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 1);
         exp = UINT64_C(0xffff7fff00008000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2580() {

{
   {
      float64x1_t arg1;
      float64x1_t arg2;
      float64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"ext64\", fnname = \"vext_f64\", rettype = \"float64x1_t\", argtypes = \"[float64x1_t,float64x1_t,__constrange(0,0) int]\", vals = [VectorVal [FloatVal 0.5569583752417361],VectorVal [FloatVal 0.7118884373756741],IndexVal 0], start_saturated = False}";
      int reported = 0;
      float64_t got;
      float64_t exp;
      arg1 = vcreate_f64(UINT64_C(0x3fe1d29a5edcb08f));
      arg2 = vcreate_f64(UINT64_C(0x3fe6c7ca429dbae5));
      clear_neon_saturated();
      //  Expect: "result" = 3fe1d29a5edcb08f
      result = vext_f64(arg1, arg2, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_f64(result, 0);
      exp = 0.5569583752417361;
      if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
         }
   }
}
}
void dotests_2581() {

{
   {
      float64x2_t arg1;
      float64x2_t arg2;
      float64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"ext64\", fnname = \"vextq_f64\", rettype = \"float64x2_t\", argtypes = \"[float64x2_t,float64x2_t,__constrange(0,1) int]\", vals = [VectorVal [FloatVal 0.3074196425744349,FloatVal 0.9283824216743759],VectorVal [FloatVal 0.7341899271889261,FloatVal 0.8049958348799154],IndexVal 1], start_saturated = True}";
      int reported = 0;
      arg1 = vcombine_f64(vcreate_f64(UINT64_C(0x3fd3acc36fc05550)),
                          vcreate_f64(UINT64_C(0x3fedb54f0d68ba2c)));
      arg2 = vcombine_f64(vcreate_f64(UINT64_C(0x3fe77e7bdfca87a6)),
                          vcreate_f64(UINT64_C(0x3fe9c286a00736e9)));
      set_neon_saturated();
      //  Expect: "result" = 3fe77e7bdfca87a63fedb54f0d68ba2c
      result = vextq_f64(arg1, arg2, 1);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      {
         float64_t got;
         float64_t exp;
         got = vgetq_lane_f64(result, 0);
         exp = 0.9283824216743759;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float64_t got;
         float64_t exp;
         got = vgetq_lane_f64(result, 1);
         exp = 0.7341899271889261;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
   }
}
}
void dotests_2582() {

{
   {
      int8x8_t arg1;
      int8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"rev64\", fnname = \"vrev64_s8\", rettype = \"int8x8_t\", argtypes = \"[int8x8_t]\", vals = [VectorVal [IntegerVal 127,IntegerVal 0,IntegerVal 0,IntegerVal (-128),IntegerVal 0,IntegerVal (-1),IntegerVal 127,IntegerVal 0]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s8(UINT64_C(0x007fff008000007f));
      clear_neon_saturated();
      //  Expect: "result" = 7f00008000ff7f00
      result = vrev64_s8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s8(result), 0);
      exp = UINT64_C(0x7f00008000ff7f00);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2583() {

{
   {
      int16x4_t arg1;
      int16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"rev64\", fnname = \"vrev64_s16\", rettype = \"int16x4_t\", argtypes = \"[int16x4_t]\", vals = [VectorVal [IntegerVal (-32768),IntegerVal 32767,IntegerVal (-32768),IntegerVal 0]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s16(UINT64_C(0x000080007fff8000));
      clear_neon_saturated();
      //  Expect: "result" = 80007fff80000000
      result = vrev64_s16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s16(result), 0);
      exp = UINT64_C(0x80007fff80000000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2584() {

{
   {
      int32x2_t arg1;
      int32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"rev64\", fnname = \"vrev64_s32\", rettype = \"int32x2_t\", argtypes = \"[int32x2_t]\", vals = [VectorVal [IntegerVal 2147450880,IntegerVal (-967361691)]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s32(UINT64_C(0xc6573b657fff8000));
      clear_neon_saturated();
      //  Expect: "result" = 7fff8000c6573b65
      result = vrev64_s32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s32(result), 0);
      exp = UINT64_C(0x7fff8000c6573b65);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2585() {

{
   {
      uint8x8_t arg1;
      uint8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"rev64\", fnname = \"vrev64_u8\", rettype = \"uint8x8_t\", argtypes = \"[uint8x8_t]\", vals = [VectorVal [IntegerVal 255,IntegerVal 127,IntegerVal 128,IntegerVal 28,IntegerVal 255,IntegerVal 127,IntegerVal 128,IntegerVal 127]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u8(UINT64_C(0x7f807fff1c807fff));
      clear_neon_saturated();
      //  Expect: "result" = ff7f801cff7f807f
      result = vrev64_u8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u8(result), 0);
      exp = UINT64_C(0xff7f801cff7f807f);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2586() {

{
   {
      uint16x4_t arg1;
      uint16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"rev64\", fnname = \"vrev64_u16\", rettype = \"uint16x4_t\", argtypes = \"[uint16x4_t]\", vals = [VectorVal [IntegerVal 1159,IntegerVal 0,IntegerVal 21467,IntegerVal 32767]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u16(UINT64_C(0x7fff53db00000487));
      clear_neon_saturated();
      //  Expect: "result" = 0487000053db7fff
      result = vrev64_u16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u16(result), 0);
      exp = UINT64_C(0x0487000053db7fff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2587() {

{
   {
      uint32x2_t arg1;
      uint32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"rev64\", fnname = \"vrev64_u32\", rettype = \"uint32x2_t\", argtypes = \"[uint32x2_t]\", vals = [VectorVal [IntegerVal 2147450880,IntegerVal 2147516416]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u32(UINT64_C(0x800080007fff8000));
      clear_neon_saturated();
      //  Expect: "result" = 7fff800080008000
      result = vrev64_u32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u32(result), 0);
      exp = UINT64_C(0x7fff800080008000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2588() {

{
   {
      poly8x8_t arg1;
      poly8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"rev64\", fnname = \"vrev64_p8\", rettype = \"poly8x8_t\", argtypes = \"[poly8x8_t]\", vals = [VectorVal [PolyVal [1,1,1,0,1,1,0,0],PolyVal [0,0,1,0,0,0,0,0],PolyVal [0,0,1,0,1,1,1,0],PolyVal [0,1,0,1,1,0,1,1],PolyVal [1,0,1,0,0,0,0,1],PolyVal [0,1,0,1,0,1,0,1],PolyVal [1,1,0,1,0,0,0,0],PolyVal [1,1,1,0,0,0,0,0]]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_p8(UINT64_C(0x070baa85da740437));
      clear_neon_saturated();
      //  Expect: "result" = 370474da85aa0b07
      result = vrev64_p8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_p8(result), 0);
      exp = UINT64_C(0x370474da85aa0b07);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2589() {

{
   {
      poly16x4_t arg1;
      poly16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"rev64\", fnname = \"vrev64_p16\", rettype = \"poly16x4_t\", argtypes = \"[poly16x4_t]\", vals = [VectorVal [PolyVal [0,1,1,0,1,1,1,1,1,1,1,1,0,1,0,1],PolyVal [0,1,1,1,0,0,0,1,1,1,0,0,1,1,1,1],PolyVal [1,0,1,1,0,1,1,0,0,0,0,0,0,0,0,0],PolyVal [0,1,1,0,1,1,1,0,0,0,0,0,1,1,1,0]]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_p16(UINT64_C(0x7076006df38eaff6));
      clear_neon_saturated();
      //  Expect: "result" = aff6f38e006d7076
      result = vrev64_p16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_p16(result), 0);
      exp = UINT64_C(0xaff6f38e006d7076);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2590() {

{
   {
      float32x2_t arg1;
      float32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"rev64\", fnname = \"vrev64_f32\", rettype = \"float32x2_t\", argtypes = \"[float32x2_t]\", vals = [VectorVal [FloatVal 0.596749484539032,FloatVal 0.3525524139404297]], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_f32(UINT64_C(0x3eb481c03f18c493));
      clear_neon_saturated();
      //  Expect: "result" = 3f18c4933eb481c0
      result = vrev64_f32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result, 0);
         exp = ((float32_t) 0.3525524139404297);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result, 1);
         exp = ((float32_t) 0.596749484539032);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
   }
}
}
void dotests_2591() {

{
   {
      int8x16_t arg1;
      int8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"rev64\", fnname = \"vrev64q_s8\", rettype = \"int8x16_t\", argtypes = \"[int8x16_t]\", vals = [VectorVal [IntegerVal (-1),IntegerVal (-122),IntegerVal 0,IntegerVal 0,IntegerVal 127,IntegerVal (-128),IntegerVal (-1),IntegerVal 127,IntegerVal 127,IntegerVal 73,IntegerVal (-56),IntegerVal (-1),IntegerVal 127,IntegerVal 112,IntegerVal 127,IntegerVal (-1)]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s8(vcreate_s8(UINT64_C(0x7fff807f000086ff)),
                         vcreate_s8(UINT64_C(0xff7f707fffc8497f)));
      clear_neon_saturated();
      //  Expect: "result" = 7f49c8ff7f707fffff8600007f80ff7f
      result = vrev64q_s8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result), 0);
         exp = UINT64_C(0xff8600007f80ff7f);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result), 1);
         exp = UINT64_C(0x7f49c8ff7f707fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2592() {

{
   {
      int16x8_t arg1;
      int16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"rev64\", fnname = \"vrev64q_s16\", rettype = \"int16x8_t\", argtypes = \"[int16x8_t]\", vals = [VectorVal [IntegerVal (-1),IntegerVal (-32768),IntegerVal 0,IntegerVal 32767,IntegerVal (-32768),IntegerVal 7765,IntegerVal 0,IntegerVal (-32768)]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s16(vcreate_s16(UINT64_C(0x7fff00008000ffff)),
                          vcreate_s16(UINT64_C(0x800000001e558000)));
      clear_neon_saturated();
      //  Expect: "result" = 80001e5500008000ffff800000007fff
      result = vrev64q_s16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 0);
         exp = UINT64_C(0xffff800000007fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 1);
         exp = UINT64_C(0x80001e5500008000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2593() {

{
   {
      int32x4_t arg1;
      int32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"rev64\", fnname = \"vrev64q_s32\", rettype = \"int32x4_t\", argtypes = \"[int32x4_t]\", vals = [VectorVal [IntegerVal (-32970),IntegerVal 32767,IntegerVal 32767,IntegerVal (-2147450881)]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s32(vcreate_s32(UINT64_C(0x00007fffffff7f36)),
                          vcreate_s32(UINT64_C(0x80007fff00007fff)));
      clear_neon_saturated();
      //  Expect: "result" = 00007fff80007fffffff7f3600007fff
      result = vrev64q_s32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 0);
         exp = UINT64_C(0xffff7f3600007fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 1);
         exp = UINT64_C(0x00007fff80007fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2594() {

{
   {
      uint8x16_t arg1;
      uint8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"rev64\", fnname = \"vrev64q_u8\", rettype = \"uint8x16_t\", argtypes = \"[uint8x16_t]\", vals = [VectorVal [IntegerVal 255,IntegerVal 128,IntegerVal 126,IntegerVal 226,IntegerVal 128,IntegerVal 127,IntegerVal 224,IntegerVal 128,IntegerVal 0,IntegerVal 219,IntegerVal 223,IntegerVal 255,IntegerVal 128,IntegerVal 128,IntegerVal 255,IntegerVal 189]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u8(vcreate_u8(UINT64_C(0x80e07f80e27e80ff)),
                         vcreate_u8(UINT64_C(0xbdff8080ffdfdb00)));
      clear_neon_saturated();
      //  Expect: "result" = 00dbdfff8080ffbdff807ee2807fe080
      result = vrev64q_u8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 0);
         exp = UINT64_C(0xff807ee2807fe080);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 1);
         exp = UINT64_C(0x00dbdfff8080ffbd);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2595() {

{
   {
      uint16x8_t arg1;
      uint16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"rev64\", fnname = \"vrev64q_u16\", rettype = \"uint16x8_t\", argtypes = \"[uint16x8_t]\", vals = [VectorVal [IntegerVal 32768,IntegerVal 0,IntegerVal 32767,IntegerVal 0,IntegerVal 40098,IntegerVal 32767,IntegerVal 32767,IntegerVal 34047]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u16(vcreate_u16(UINT64_C(0x00007fff00008000)),
                          vcreate_u16(UINT64_C(0x84ff7fff7fff9ca2)));
      clear_neon_saturated();
      //  Expect: "result" = 9ca27fff7fff84ff800000007fff0000
      result = vrev64q_u16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 0);
         exp = UINT64_C(0x800000007fff0000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 1);
         exp = UINT64_C(0x9ca27fff7fff84ff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2596() {

{
   {
      uint32x4_t arg1;
      uint32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"rev64\", fnname = \"vrev64q_u32\", rettype = \"uint32x4_t\", argtypes = \"[uint32x4_t]\", vals = [VectorVal [IntegerVal 2147450879,IntegerVal 2147516416,IntegerVal 4294934527,IntegerVal 2147549183]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u32(vcreate_u32(UINT64_C(0x800080007fff7fff)),
                          vcreate_u32(UINT64_C(0x8000ffffffff7fff)));
      clear_neon_saturated();
      //  Expect: "result" = ffff7fff8000ffff7fff7fff80008000
      result = vrev64q_u32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 0);
         exp = UINT64_C(0x7fff7fff80008000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 1);
         exp = UINT64_C(0xffff7fff8000ffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2597() {

{
   {
      poly8x16_t arg1;
      poly8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"rev64\", fnname = \"vrev64q_p8\", rettype = \"poly8x16_t\", argtypes = \"[poly8x16_t]\", vals = [VectorVal [PolyVal [1,1,1,0,1,1,1,0],PolyVal [0,1,1,1,0,1,1,0],PolyVal [0,0,1,0,0,0,0,1],PolyVal [1,1,0,0,0,1,1,0],PolyVal [1,1,0,0,0,1,1,1],PolyVal [1,1,0,1,0,1,1,0],PolyVal [0,1,0,1,0,1,1,1],PolyVal [1,1,1,1,0,0,1,0],PolyVal [0,0,0,0,0,0,0,0],PolyVal [0,0,0,0,1,1,1,0],PolyVal [1,0,1,1,0,0,1,1],PolyVal [0,0,1,1,1,1,1,1],PolyVal [1,1,1,1,1,1,1,1],PolyVal [0,1,0,1,0,1,1,0],PolyVal [1,0,0,1,0,0,1,1],PolyVal [1,1,0,0,0,1,1,1]]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_p8(vcreate_p8(UINT64_C(0x4fea6be363846e77)),
                         vcreate_p8(UINT64_C(0xe3c96afffccd7000)));
      clear_neon_saturated();
      //  Expect: "result" = 0070cdfcff6ac9e3776e8463e36bea4f
      result = vrev64q_p8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p8(result), 0);
         exp = UINT64_C(0x776e8463e36bea4f);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p8(result), 1);
         exp = UINT64_C(0x0070cdfcff6ac9e3);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2598() {

{
   {
      poly16x8_t arg1;
      poly16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"rev64\", fnname = \"vrev64q_p16\", rettype = \"poly16x8_t\", argtypes = \"[poly16x8_t]\", vals = [VectorVal [PolyVal [0,0,0,1,1,0,0,0,0,1,0,1,1,0,1,0],PolyVal [0,1,1,1,0,1,0,1,0,1,0,1,1,0,1,1],PolyVal [1,0,1,1,0,0,1,0,0,1,0,1,0,0,0,1],PolyVal [0,0,0,1,1,1,0,1,0,0,1,1,1,1,0,0],PolyVal [0,0,1,1,0,1,0,1,1,0,1,1,0,1,1,1],PolyVal [0,0,0,1,0,1,0,1,0,0,1,1,1,0,1,0],PolyVal [1,1,1,1,1,0,1,1,1,0,0,0,0,1,1,1],PolyVal [0,1,1,1,0,1,1,1,0,0,1,1,0,0,0,0]]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_p16(vcreate_p16(UINT64_C(0x3cb88a4ddaae5a18)),
                          vcreate_p16(UINT64_C(0x0ceee1df5ca8edac)));
      clear_neon_saturated();
      //  Expect: "result" = edac5ca8e1df0cee5a18daae8a4d3cb8
      result = vrev64q_p16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p16(result), 0);
         exp = UINT64_C(0x5a18daae8a4d3cb8);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p16(result), 1);
         exp = UINT64_C(0xedac5ca8e1df0cee);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2599() {

{
   {
      float32x4_t arg1;
      float32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"rev64\", fnname = \"vrev64q_f32\", rettype = \"float32x4_t\", argtypes = \"[float32x4_t]\", vals = [VectorVal [FloatVal 0.37100160121917725,FloatVal 9.244728088378906e-2,FloatVal 0.5047798156738281,FloatVal 0.6553412079811096]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_f32(vcreate_f32(UINT64_C(0x3dbd55003ebdf3ec)),
                          vcreate_f32(UINT64_C(0x3f27c4713f013940)));
      clear_neon_saturated();
      //  Expect: "result" = 3f0139403f27c4713ebdf3ec3dbd5500
      result = vrev64q_f32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 0);
         exp = ((float32_t) 9.244728088378906e-2);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 1);
         exp = ((float32_t) 0.37100160121917725);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 2);
         exp = ((float32_t) 0.6553412079811096);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 2 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 3);
         exp = ((float32_t) 0.5047798156738281);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 3 ", exp, got);
            }
      }
   }
}
}
void dotests_2600() {

{
   {
      int8x8_t arg1;
      int8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"rev32\", fnname = \"vrev32_s8\", rettype = \"int8x8_t\", argtypes = \"[int8x8_t]\", vals = [VectorVal [IntegerVal (-96),IntegerVal 127,IntegerVal (-39),IntegerVal 3,IntegerVal 127,IntegerVal 56,IntegerVal (-1),IntegerVal 0]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s8(UINT64_C(0x00ff387f03d97fa0));
      clear_neon_saturated();
      //  Expect: "result" = 7f38ff00a07fd903
      result = vrev32_s8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s8(result), 0);
      exp = UINT64_C(0x7f38ff00a07fd903);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2601() {

{
   {
      int16x4_t arg1;
      int16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"rev32\", fnname = \"vrev32_s16\", rettype = \"int16x4_t\", argtypes = \"[int16x4_t]\", vals = [VectorVal [IntegerVal 32767,IntegerVal 0,IntegerVal (-32768),IntegerVal 32767]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s16(UINT64_C(0x7fff800000007fff));
      clear_neon_saturated();
      //  Expect: "result" = 80007fff7fff0000
      result = vrev32_s16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s16(result), 0);
      exp = UINT64_C(0x80007fff7fff0000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2602() {

{
   {
      uint8x8_t arg1;
      uint8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"rev32\", fnname = \"vrev32_u8\", rettype = \"uint8x8_t\", argtypes = \"[uint8x8_t]\", vals = [VectorVal [IntegerVal 255,IntegerVal 127,IntegerVal 255,IntegerVal 128,IntegerVal 0,IntegerVal 127,IntegerVal 127,IntegerVal 128]], start_saturated = True}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u8(UINT64_C(0x807f7f0080ff7fff));
      set_neon_saturated();
      //  Expect: "result" = 007f7f80ff7fff80
      result = vrev32_u8(arg1);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u8(result), 0);
      exp = UINT64_C(0x007f7f80ff7fff80);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2603() {

{
   {
      uint16x4_t arg1;
      uint16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"rev32\", fnname = \"vrev32_u16\", rettype = \"uint16x4_t\", argtypes = \"[uint16x4_t]\", vals = [VectorVal [IntegerVal 0,IntegerVal 32768,IntegerVal 65535,IntegerVal 32767]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u16(UINT64_C(0x7fffffff80000000));
      clear_neon_saturated();
      //  Expect: "result" = ffff7fff00008000
      result = vrev32_u16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u16(result), 0);
      exp = UINT64_C(0xffff7fff00008000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2604() {

{
   {
      poly8x8_t arg1;
      poly8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"rev32\", fnname = \"vrev32_p8\", rettype = \"poly8x8_t\", argtypes = \"[poly8x8_t]\", vals = [VectorVal [PolyVal [0,1,1,0,1,0,1,0],PolyVal [1,0,1,1,0,1,1,1],PolyVal [1,0,0,0,0,1,0,0],PolyVal [1,1,1,1,1,1,0,1],PolyVal [1,1,1,1,1,1,0,0],PolyVal [1,0,1,0,0,0,0,0],PolyVal [0,0,1,1,1,1,1,0],PolyVal [0,0,1,0,1,0,1,1]]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_p8(UINT64_C(0xd47c053fbf21ed56));
      clear_neon_saturated();
      //  Expect: "result" = 3f057cd456ed21bf
      result = vrev32_p8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_p8(result), 0);
      exp = UINT64_C(0x3f057cd456ed21bf);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2605() {

{
   {
      poly16x4_t arg1;
      poly16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"rev32\", fnname = \"vrev32_p16\", rettype = \"poly16x4_t\", argtypes = \"[poly16x4_t]\", vals = [VectorVal [PolyVal [0,1,1,0,0,1,0,1,1,1,0,0,0,1,0,0],PolyVal [0,1,1,0,0,0,1,1,0,0,0,1,0,0,1,0],PolyVal [0,0,0,1,0,0,1,1,0,1,0,1,0,0,1,0],PolyVal [0,0,1,1,0,1,1,1,1,1,0,1,1,1,1,1]]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_p16(UINT64_C(0xfbec4ac848c623a6));
      clear_neon_saturated();
      //  Expect: "result" = 4ac8fbec23a648c6
      result = vrev32_p16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_p16(result), 0);
      exp = UINT64_C(0x4ac8fbec23a648c6);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2606() {

{
   {
      int8x16_t arg1;
      int8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"rev32\", fnname = \"vrev32q_s8\", rettype = \"int8x16_t\", argtypes = \"[int8x16_t]\", vals = [VectorVal [IntegerVal (-128),IntegerVal (-128),IntegerVal 9,IntegerVal (-128),IntegerVal 0,IntegerVal (-1),IntegerVal 127,IntegerVal 41,IntegerVal (-128),IntegerVal 0,IntegerVal 127,IntegerVal (-22),IntegerVal (-1),IntegerVal (-128),IntegerVal 127,IntegerVal 0]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s8(vcreate_s8(UINT64_C(0x297fff0080098080)),
                         vcreate_s8(UINT64_C(0x007f80ffea7f0080)));
      clear_neon_saturated();
      //  Expect: "result" = ff807f0080007fea00ff7f2980800980
      result = vrev32q_s8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result), 0);
         exp = UINT64_C(0x00ff7f2980800980);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result), 1);
         exp = UINT64_C(0xff807f0080007fea);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2607() {

{
   {
      int16x8_t arg1;
      int16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"rev32\", fnname = \"vrev32q_s16\", rettype = \"int16x8_t\", argtypes = \"[int16x8_t]\", vals = [VectorVal [IntegerVal 32767,IntegerVal (-32768),IntegerVal (-1),IntegerVal (-1),IntegerVal (-1),IntegerVal 0,IntegerVal 0,IntegerVal (-32768)]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s16(vcreate_s16(UINT64_C(0xffffffff80007fff)),
                          vcreate_s16(UINT64_C(0x800000000000ffff)));
      clear_neon_saturated();
      //  Expect: "result" = 00008000ffff0000ffffffff7fff8000
      result = vrev32q_s16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 0);
         exp = UINT64_C(0xffffffff7fff8000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 1);
         exp = UINT64_C(0x00008000ffff0000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2608() {

{
   {
      uint8x16_t arg1;
      uint8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"rev32\", fnname = \"vrev32q_u8\", rettype = \"uint8x16_t\", argtypes = \"[uint8x16_t]\", vals = [VectorVal [IntegerVal 128,IntegerVal 0,IntegerVal 127,IntegerVal 128,IntegerVal 128,IntegerVal 127,IntegerVal 0,IntegerVal 255,IntegerVal 255,IntegerVal 0,IntegerVal 128,IntegerVal 255,IntegerVal 219,IntegerVal 128,IntegerVal 255,IntegerVal 127]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u8(vcreate_u8(UINT64_C(0xff007f80807f0080)),
                         vcreate_u8(UINT64_C(0x7fff80dbff8000ff)));
      clear_neon_saturated();
      //  Expect: "result" = db80ff7fff0080ff807f00ff80007f80
      result = vrev32q_u8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 0);
         exp = UINT64_C(0x807f00ff80007f80);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 1);
         exp = UINT64_C(0xdb80ff7fff0080ff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2609() {

{
   {
      uint16x8_t arg1;
      uint16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"rev32\", fnname = \"vrev32q_u16\", rettype = \"uint16x8_t\", argtypes = \"[uint16x8_t]\", vals = [VectorVal [IntegerVal 32768,IntegerVal 32767,IntegerVal 32767,IntegerVal 0,IntegerVal 32767,IntegerVal 0,IntegerVal 36278,IntegerVal 0]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u16(vcreate_u16(UINT64_C(0x00007fff7fff8000)),
                          vcreate_u16(UINT64_C(0x00008db600007fff)));
      clear_neon_saturated();
      //  Expect: "result" = 8db600007fff00007fff000080007fff
      result = vrev32q_u16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 0);
         exp = UINT64_C(0x7fff000080007fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 1);
         exp = UINT64_C(0x8db600007fff0000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2610() {

{
   {
      poly8x16_t arg1;
      poly8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"rev32\", fnname = \"vrev32q_p8\", rettype = \"poly8x16_t\", argtypes = \"[poly8x16_t]\", vals = [VectorVal [PolyVal [1,1,0,0,0,1,0,1],PolyVal [1,1,0,0,0,0,1,1],PolyVal [1,0,1,1,1,0,1,1],PolyVal [0,1,0,0,1,1,1,0],PolyVal [0,0,0,1,0,0,1,1],PolyVal [0,0,0,1,0,1,1,0],PolyVal [0,0,1,1,1,1,0,1],PolyVal [1,0,1,0,0,1,0,1],PolyVal [1,0,1,0,0,0,0,1],PolyVal [1,1,1,1,0,1,1,0],PolyVal [1,0,0,1,1,0,1,0],PolyVal [1,1,1,1,1,1,1,0],PolyVal [0,0,1,1,0,0,1,0],PolyVal [1,1,0,1,0,0,1,0],PolyVal [0,1,0,1,0,0,1,0],PolyVal [0,1,0,0,0,0,0,0]]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_p8(vcreate_p8(UINT64_C(0xa5bc68c872ddc3a3)),
                         vcreate_p8(UINT64_C(0x024a4b4c7f596f85)));
      clear_neon_saturated();
      //  Expect: "result" = 4c4b4a02856f597fc868bca5a3c3dd72
      result = vrev32q_p8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p8(result), 0);
         exp = UINT64_C(0xc868bca5a3c3dd72);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p8(result), 1);
         exp = UINT64_C(0x4c4b4a02856f597f);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2611() {

{
   {
      poly16x8_t arg1;
      poly16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"rev32\", fnname = \"vrev32q_p16\", rettype = \"poly16x8_t\", argtypes = \"[poly16x8_t]\", vals = [VectorVal [PolyVal [0,1,0,0,1,0,1,1,0,0,1,0,0,0,0,1],PolyVal [1,1,1,1,0,1,1,0,1,0,1,1,1,0,1,1],PolyVal [0,1,1,1,0,0,0,1,0,1,0,0,1,0,1,1],PolyVal [1,0,0,1,1,0,1,1,1,1,0,1,1,0,0,1],PolyVal [1,0,1,1,1,1,0,1,1,0,1,0,0,0,1,0],PolyVal [0,1,1,0,0,1,1,1,0,0,1,1,0,0,0,1],PolyVal [1,1,0,0,1,0,0,1,0,0,1,0,1,1,1,0],PolyVal [0,1,0,0,1,0,1,0,1,1,1,1,1,1,0,0]]], start_saturated = True}";
      int reported = 0;
      arg1 = vcombine_p16(vcreate_p16(UINT64_C(0x9bd9d28edd6f84d2)),
                          vcreate_p16(UINT64_C(0x3f5274938ce645bd)));
      set_neon_saturated();
      //  Expect: "result" = 74933f5245bd8ce6d28e9bd984d2dd6f
      result = vrev32q_p16(arg1);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p16(result), 0);
         exp = UINT64_C(0xd28e9bd984d2dd6f);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p16(result), 1);
         exp = UINT64_C(0x74933f5245bd8ce6);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2612() {

{
   {
      int8x8_t arg1;
      int8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"rev16\", fnname = \"vrev16_s8\", rettype = \"int8x8_t\", argtypes = \"[int8x8_t]\", vals = [VectorVal [IntegerVal 0,IntegerVal (-1),IntegerVal (-1),IntegerVal (-128),IntegerVal (-128),IntegerVal (-15),IntegerVal (-128),IntegerVal 127]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s8(UINT64_C(0x7f80f18080ffff00));
      clear_neon_saturated();
      //  Expect: "result" = 807f80f1ff8000ff
      result = vrev16_s8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s8(result), 0);
      exp = UINT64_C(0x807f80f1ff8000ff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2613() {

{
   {
      uint8x8_t arg1;
      uint8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"rev16\", fnname = \"vrev16_u8\", rettype = \"uint8x8_t\", argtypes = \"[uint8x8_t]\", vals = [VectorVal [IntegerVal 255,IntegerVal 0,IntegerVal 255,IntegerVal 128,IntegerVal 201,IntegerVal 255,IntegerVal 255,IntegerVal 255]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u8(UINT64_C(0xffffffc980ff00ff));
      clear_neon_saturated();
      //  Expect: "result" = ffffc9ffff80ff00
      result = vrev16_u8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u8(result), 0);
      exp = UINT64_C(0xffffc9ffff80ff00);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2614() {

{
   {
      poly8x8_t arg1;
      poly8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"rev16\", fnname = \"vrev16_p8\", rettype = \"poly8x8_t\", argtypes = \"[poly8x8_t]\", vals = [VectorVal [PolyVal [0,1,1,0,0,0,0,0],PolyVal [1,1,1,1,1,1,0,1],PolyVal [1,1,1,1,0,1,0,1],PolyVal [0,0,0,1,0,1,1,0],PolyVal [0,0,0,0,1,1,0,0],PolyVal [0,1,0,1,0,0,1,1],PolyVal [0,0,0,0,0,1,0,0],PolyVal [1,0,1,1,0,0,1,0]]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_p8(UINT64_C(0x4d20ca3068afbf06));
      clear_neon_saturated();
      //  Expect: "result" = 204d30caaf6806bf
      result = vrev16_p8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_p8(result), 0);
      exp = UINT64_C(0x204d30caaf6806bf);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2615() {

{
   {
      int8x16_t arg1;
      int8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"rev16\", fnname = \"vrev16q_s8\", rettype = \"int8x16_t\", argtypes = \"[int8x16_t]\", vals = [VectorVal [IntegerVal (-128),IntegerVal (-128),IntegerVal (-1),IntegerVal (-128),IntegerVal 0,IntegerVal 127,IntegerVal 0,IntegerVal 127,IntegerVal (-128),IntegerVal (-128),IntegerVal (-128),IntegerVal 127,IntegerVal (-128),IntegerVal 21,IntegerVal (-49),IntegerVal (-43)]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s8(vcreate_s8(UINT64_C(0x7f007f0080ff8080)),
                         vcreate_s8(UINT64_C(0xd5cf15807f808080)));
      clear_neon_saturated();
      //  Expect: "result" = cfd58015807f8080007f007fff808080
      result = vrev16q_s8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result), 0);
         exp = UINT64_C(0x007f007fff808080);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result), 1);
         exp = UINT64_C(0xcfd58015807f8080);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2616() {

{
   {
      uint8x16_t arg1;
      uint8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"rev16\", fnname = \"vrev16q_u8\", rettype = \"uint8x16_t\", argtypes = \"[uint8x16_t]\", vals = [VectorVal [IntegerVal 127,IntegerVal 255,IntegerVal 133,IntegerVal 128,IntegerVal 255,IntegerVal 127,IntegerVal 0,IntegerVal 255,IntegerVal 197,IntegerVal 128,IntegerVal 255,IntegerVal 127,IntegerVal 0,IntegerVal 128,IntegerVal 127,IntegerVal 226]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u8(vcreate_u8(UINT64_C(0xff007fff8085ff7f)),
                         vcreate_u8(UINT64_C(0xe27f80007fff80c5)));
      clear_neon_saturated();
      //  Expect: "result" = 7fe20080ff7fc58000ffff7f85807fff
      result = vrev16q_u8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 0);
         exp = UINT64_C(0x00ffff7f85807fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 1);
         exp = UINT64_C(0x7fe20080ff7fc580);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2617() {

{
   {
      poly8x16_t arg1;
      poly8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"rev16\", fnname = \"vrev16q_p8\", rettype = \"poly8x16_t\", argtypes = \"[poly8x16_t]\", vals = [VectorVal [PolyVal [0,0,0,0,1,0,1,0],PolyVal [0,0,0,0,0,0,0,0],PolyVal [1,1,1,1,0,1,0,0],PolyVal [1,1,0,0,0,1,0,1],PolyVal [0,0,0,1,0,0,1,1],PolyVal [0,1,0,1,1,0,0,0],PolyVal [1,0,1,0,0,0,1,1],PolyVal [1,0,1,1,0,1,1,1],PolyVal [1,1,0,0,0,1,0,1],PolyVal [0,0,1,1,0,1,1,1],PolyVal [0,0,1,1,1,1,0,1],PolyVal [1,0,0,1,0,1,0,1],PolyVal [0,1,0,1,1,1,0,0],PolyVal [0,0,0,1,1,0,0,0],PolyVal [0,0,0,0,0,1,1,1],PolyVal [1,0,0,1,0,1,1,1]]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_p8(vcreate_p8(UINT64_C(0xedc51ac8a32f0050)),
                         vcreate_p8(UINT64_C(0xe9e0183aa9bceca3)));
      clear_neon_saturated();
      //  Expect: "result" = e0e93a18bca9a3ecc5edc81a2fa35000
      result = vrev16q_p8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p8(result), 0);
         exp = UINT64_C(0xc5edc81a2fa35000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p8(result), 1);
         exp = UINT64_C(0xe0e93a18bca9a3ec);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2618() {

{
   {
      int8x8_t arg1;
      int8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"abs\", fnname = \"vabs_s8\", rettype = \"int8x8_t\", argtypes = \"[int8x8_t]\", vals = [VectorVal [IntegerVal 127,IntegerVal 127,IntegerVal 0,IntegerVal 127,IntegerVal 127,IntegerVal (-1),IntegerVal 0,IntegerVal 0]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s8(UINT64_C(0x0000ff7f7f007f7f));
      clear_neon_saturated();
      //  Expect: "result" = 0000017f7f007f7f
      result = vabs_s8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s8(result), 0);
      exp = UINT64_C(0x0000017f7f007f7f);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2619() {

{
   {
      int16x4_t arg1;
      int16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"abs\", fnname = \"vabs_s16\", rettype = \"int16x4_t\", argtypes = \"[int16x4_t]\", vals = [VectorVal [IntegerVal (-32768),IntegerVal (-32768),IntegerVal (-1),IntegerVal 32767]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s16(UINT64_C(0x7fffffff80008000));
      clear_neon_saturated();
      //  Expect: "result" = 7fff000180008000
      result = vabs_s16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s16(result), 0);
      exp = UINT64_C(0x7fff000180008000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2620() {

{
   {
      int32x2_t arg1;
      int32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"abs\", fnname = \"vabs_s32\", rettype = \"int32x2_t\", argtypes = \"[int32x2_t]\", vals = [VectorVal [IntegerVal (-1457258497),IntegerVal 738885631]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s32(UINT64_C(0x2c0a7fffa923ffff));
      clear_neon_saturated();
      //  Expect: "result" = 2c0a7fff56dc0001
      result = vabs_s32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s32(result), 0);
      exp = UINT64_C(0x2c0a7fff56dc0001);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2621() {

{
   {
      float32x2_t arg1;
      float32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"abs\", fnname = \"vabs_f32\", rettype = \"float32x2_t\", argtypes = \"[float32x2_t]\", vals = [VectorVal [FloatVal 0.787327766418457,FloatVal 0.727979838848114]], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_f32(UINT64_C(0x3f3a5ce33f498e50));
      clear_neon_saturated();
      //  Expect: "result" = 3f3a5ce33f498e50
      result = vabs_f32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result, 0);
         exp = ((float32_t) 0.787327766418457);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result, 1);
         exp = ((float32_t) 0.727979838848114);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
   }
}
}
void dotests_2622() {

{
   {
      int8x16_t arg1;
      int8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"abs\", fnname = \"vabsq_s8\", rettype = \"int8x16_t\", argtypes = \"[int8x16_t]\", vals = [VectorVal [IntegerVal (-128),IntegerVal 110,IntegerVal 127,IntegerVal 0,IntegerVal 127,IntegerVal (-1),IntegerVal 0,IntegerVal (-128),IntegerVal 127,IntegerVal 116,IntegerVal 41,IntegerVal (-128),IntegerVal (-1),IntegerVal 127,IntegerVal (-128),IntegerVal (-90)]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s8(vcreate_s8(UINT64_C(0x8000ff7f007f6e80)),
                         vcreate_s8(UINT64_C(0xa6807fff8029747f)));
      clear_neon_saturated();
      //  Expect: "result" = 5a807f018029747f8000017f007f6e80
      result = vabsq_s8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result), 0);
         exp = UINT64_C(0x8000017f007f6e80);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result), 1);
         exp = UINT64_C(0x5a807f018029747f);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2623() {

{
   {
      int16x8_t arg1;
      int16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"abs\", fnname = \"vabsq_s16\", rettype = \"int16x8_t\", argtypes = \"[int16x8_t]\", vals = [VectorVal [IntegerVal 14647,IntegerVal 32767,IntegerVal (-32768),IntegerVal 0,IntegerVal (-2230),IntegerVal (-16811),IntegerVal (-32768),IntegerVal (-32768)]], start_saturated = True}";
      int reported = 0;
      arg1 = vcombine_s16(vcreate_s16(UINT64_C(0x000080007fff3937)),
                          vcreate_s16(UINT64_C(0x80008000be55f74a)));
      set_neon_saturated();
      //  Expect: "result" = 8000800041ab08b6000080007fff3937
      result = vabsq_s16(arg1);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 0);
         exp = UINT64_C(0x000080007fff3937);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 1);
         exp = UINT64_C(0x8000800041ab08b6);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2624() {

{
   {
      int32x4_t arg1;
      int32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"abs\", fnname = \"vabsq_s32\", rettype = \"int32x4_t\", argtypes = \"[int32x4_t]\", vals = [VectorVal [IntegerVal (-65536),IntegerVal 1830617087,IntegerVal (-32768),IntegerVal 1192132608]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s32(vcreate_s32(UINT64_C(0x6d1cffffffff0000)),
                          vcreate_s32(UINT64_C(0x470e8000ffff8000)));
      clear_neon_saturated();
      //  Expect: "result" = 470e8000000080006d1cffff00010000
      result = vabsq_s32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 0);
         exp = UINT64_C(0x6d1cffff00010000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 1);
         exp = UINT64_C(0x470e800000008000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2625() {

{
   {
      float32x4_t arg1;
      float32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"abs\", fnname = \"vabsq_f32\", rettype = \"float32x4_t\", argtypes = \"[float32x4_t]\", vals = [VectorVal [FloatVal 0.7392889857292175,FloatVal 0.15381383895874023,FloatVal 0.13963031768798828,FloatVal 0.9006614685058594]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_f32(vcreate_f32(UINT64_C(0x3e1d81603f3d420b)),
                          vcreate_f32(UINT64_C(0x3f6691c03e0efb40)));
      clear_neon_saturated();
      //  Expect: "result" = 3f6691c03e0efb403e1d81603f3d420b
      result = vabsq_f32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 0);
         exp = ((float32_t) 0.7392889857292175);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 1);
         exp = ((float32_t) 0.15381383895874023);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 2);
         exp = ((float32_t) 0.13963031768798828);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 2 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 3);
         exp = ((float32_t) 0.9006614685058594);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 3 ", exp, got);
            }
      }
   }
}
}
void dotests_2626() {

{
   {
      int64x1_t arg1;
      int64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"abs\", fnname = \"vabs_s64\", rettype = \"int64x1_t\", argtypes = \"[int64x1_t]\", vals = [VectorVal [IntegerVal 9223231299366387712]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s64(UINT64_C(0x7fff7fffffff8000));
      clear_neon_saturated();
      //  Expect: "result" = 7fff7fffffff8000
      result = vabs_s64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s64(result), 0);
      exp = UINT64_C(0x7fff7fffffff8000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2627() {

{
   {
      float64x1_t arg1;
      float64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"abs\", fnname = \"vabs_f64\", rettype = \"float64x1_t\", argtypes = \"[float64x1_t]\", vals = [VectorVal [FloatVal 0.5582191416328712]], start_saturated = False}";
      int reported = 0;
      float64_t got;
      float64_t exp;
      arg1 = vcreate_f64(UINT64_C(0x3fe1dcee63aa0f5a));
      clear_neon_saturated();
      //  Expect: "result" = 3fe1dcee63aa0f5a
      result = vabs_f64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_f64(result, 0);
      exp = 0.5582191416328712;
      if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
         }
   }
}
}
void dotests_2628() {

{
   {
      int64x2_t arg1;
      int64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"abs\", fnname = \"vabsq_s64\", rettype = \"int64x2_t\", argtypes = \"[int64x2_t]\", vals = [VectorVal [IntegerVal 9223372034707323366,IntegerVal 4294902465]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s64(vcreate_s64(UINT64_C(0x7fffffff800079e6)),
                          vcreate_s64(UINT64_C(0x00000000ffff02c1)));
      clear_neon_saturated();
      //  Expect: "result" = 00000000ffff02c17fffffff800079e6
      result = vabsq_s64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 0);
         exp = UINT64_C(0x7fffffff800079e6);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 1);
         exp = UINT64_C(0x00000000ffff02c1);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2629() {

{
   {
      float64x2_t arg1;
      float64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"abs\", fnname = \"vabsq_f64\", rettype = \"float64x2_t\", argtypes = \"[float64x2_t]\", vals = [VectorVal [FloatVal 0.41125322602615344,FloatVal 0.6854140638956737]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_f64(vcreate_f64(UINT64_C(0x3fda51f90d0a096c)),
                          vcreate_f64(UINT64_C(0x3fe5eee97994cfdb)));
      clear_neon_saturated();
      //  Expect: "result" = 3fe5eee97994cfdb3fda51f90d0a096c
      result = vabsq_f64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float64_t got;
         float64_t exp;
         got = vgetq_lane_f64(result, 0);
         exp = 0.41125322602615344;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float64_t got;
         float64_t exp;
         got = vgetq_lane_f64(result, 1);
         exp = 0.6854140638956737;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
   }
}
}
void dotests_2630() {

{
   {
      int8x8_t arg1;
      int8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"qabs\", fnname = \"vqabs_s8\", rettype = \"int8x8_t\", argtypes = \"[int8x8_t]\", vals = [VectorVal [IntegerVal (-128),IntegerVal 19,IntegerVal (-128),IntegerVal 0,IntegerVal 0,IntegerVal (-1),IntegerVal 127,IntegerVal (-44)]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s8(UINT64_C(0xd47fff0000801380));
      clear_neon_saturated();
      //  Expect: "result" = 2c7f0100007f137f
      result = vqabs_s8(arg1);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s8(result), 0);
      exp = UINT64_C(0x2c7f0100007f137f);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2631() {

{
   {
      int16x4_t arg1;
      int16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"qabs\", fnname = \"vqabs_s16\", rettype = \"int16x4_t\", argtypes = \"[int16x4_t]\", vals = [VectorVal [IntegerVal (-32768),IntegerVal (-32768),IntegerVal (-1),IntegerVal (-32768)]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s16(UINT64_C(0x8000ffff80008000));
      clear_neon_saturated();
      //  Expect: "result" = 7fff00017fff7fff
      result = vqabs_s16(arg1);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s16(result), 0);
      exp = UINT64_C(0x7fff00017fff7fff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2632() {

{
   {
      int32x2_t arg1;
      int32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"qabs\", fnname = \"vqabs_s32\", rettype = \"int32x2_t\", argtypes = \"[int32x2_t]\", vals = [VectorVal [IntegerVal (-390660096),IntegerVal 1822261248]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s32(UINT64_C(0x6c9d8000e8b70000));
      clear_neon_saturated();
      //  Expect: "result" = 6c9d800017490000
      result = vqabs_s32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s32(result), 0);
      exp = UINT64_C(0x6c9d800017490000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2633() {

{
   {
      int8x16_t arg1;
      int8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"qabs\", fnname = \"vqabsq_s8\", rettype = \"int8x16_t\", argtypes = \"[int8x16_t]\", vals = [VectorVal [IntegerVal (-68),IntegerVal (-1),IntegerVal 0,IntegerVal (-1),IntegerVal 0,IntegerVal (-128),IntegerVal (-128),IntegerVal (-1),IntegerVal (-1),IntegerVal (-4),IntegerVal (-1),IntegerVal (-1),IntegerVal 0,IntegerVal (-29),IntegerVal (-1),IntegerVal 0]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s8(vcreate_s8(UINT64_C(0xff808000ff00ffbc)),
                         vcreate_s8(UINT64_C(0x00ffe300fffffcff)));
      clear_neon_saturated();
      //  Expect: "result" = 00011d0001010401017f7f0001000144
      result = vqabsq_s8(arg1);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result), 0);
         exp = UINT64_C(0x017f7f0001000144);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result), 1);
         exp = UINT64_C(0x00011d0001010401);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2634() {

{
   {
      int16x8_t arg1;
      int16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"qabs\", fnname = \"vqabsq_s16\", rettype = \"int16x8_t\", argtypes = \"[int16x8_t]\", vals = [VectorVal [IntegerVal (-1),IntegerVal 0,IntegerVal 4709,IntegerVal (-32768),IntegerVal 32767,IntegerVal (-1),IntegerVal (-32768),IntegerVal (-32768)]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s16(vcreate_s16(UINT64_C(0x800012650000ffff)),
                          vcreate_s16(UINT64_C(0x80008000ffff7fff)));
      clear_neon_saturated();
      //  Expect: "result" = 7fff7fff00017fff7fff126500000001
      result = vqabsq_s16(arg1);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 0);
         exp = UINT64_C(0x7fff126500000001);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 1);
         exp = UINT64_C(0x7fff7fff00017fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2635() {

{
   {
      int32x4_t arg1;
      int32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"qabs\", fnname = \"vqabsq_s32\", rettype = \"int32x4_t\", argtypes = \"[int32x4_t]\", vals = [VectorVal [IntegerVal 812089343,IntegerVal (-65536),IntegerVal (-32769),IntegerVal 32768]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s32(vcreate_s32(UINT64_C(0xffff000030677fff)),
                          vcreate_s32(UINT64_C(0x00008000ffff7fff)));
      clear_neon_saturated();
      //  Expect: "result" = 00008000000080010001000030677fff
      result = vqabsq_s32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 0);
         exp = UINT64_C(0x0001000030677fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 1);
         exp = UINT64_C(0x0000800000008001);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2636() {

{
   {
      int64x1_t arg1;
      int64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"qabs\", fnname = \"vqabs_s64\", rettype = \"int64x1_t\", argtypes = \"[int64x1_t]\", vals = [VectorVal [IntegerVal 4673469775018098688]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s64(UINT64_C(0x40db7fffd07a8000));
      clear_neon_saturated();
      //  Expect: "result" = 40db7fffd07a8000
      result = vqabs_s64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s64(result), 0);
      exp = UINT64_C(0x40db7fffd07a8000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2637() {

{
   {
      int64x2_t arg1;
      int64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"qabs\", fnname = \"vqabsq_s64\", rettype = \"int64x2_t\", argtypes = \"[int64x2_t]\", vals = [VectorVal [IntegerVal (-9223231297218969600),IntegerVal (-9223231299366486016)]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s64(vcreate_s64(UINT64_C(0x800080007fff8000)),
                          vcreate_s64(UINT64_C(0x80007fffffff0000)));
      clear_neon_saturated();
      //  Expect: "result" = 7fff8000000100007fff7fff80008000
      result = vqabsq_s64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 0);
         exp = UINT64_C(0x7fff7fff80008000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 1);
         exp = UINT64_C(0x7fff800000010000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2638() {

{
   {
      int8_t arg1;
      int8_t result;
      char* str1 = "ReproInfo2 {semantics = \"qabs\", fnname = \"vqabsb_s8\", rettype = \"int8_t\", argtypes = \"[int8_t]\", vals = [IntegerVal 127], start_saturated = False}";
      int reported = 0;
      int8_t got;
      int8_t exp;
      arg1 = 127;
      clear_neon_saturated();
      //  Expect: "result" = 7f
      result = vqabsb_s8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = 127;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2639() {

{
   {
      int16_t arg1;
      int16_t result;
      char* str1 = "ReproInfo2 {semantics = \"qabs\", fnname = \"vqabsh_s16\", rettype = \"int16_t\", argtypes = \"[int16_t]\", vals = [IntegerVal (-1)], start_saturated = False}";
      int reported = 0;
      int16_t got;
      int16_t exp;
      arg1 = -1;
      clear_neon_saturated();
      //  Expect: "result" = 0001
      result = vqabsh_s16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = 1;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIi16 " Got: %" PRIi16 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2640() {

{
   {
      int32_t arg1;
      int32_t result;
      char* str1 = "ReproInfo2 {semantics = \"qabs\", fnname = \"vqabss_s32\", rettype = \"int32_t\", argtypes = \"[int32_t]\", vals = [IntegerVal 2147450880], start_saturated = False}";
      int reported = 0;
      int32_t got;
      int32_t exp;
      arg1 = 2147450880;
      clear_neon_saturated();
      //  Expect: "result" = 7fff8000
      result = vqabss_s32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = 2147450880;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIi32 " Got: %" PRIi32 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2641() {

{
   {
      int64_t arg1;
      int64_t result;
      char* str1 = "ReproInfo2 {semantics = \"qabs\", fnname = \"vqabsd_s64\", rettype = \"int64_t\", argtypes = \"[int64_t]\", vals = [IntegerVal 2147450879], start_saturated = False}";
      int reported = 0;
      int64_t got;
      int64_t exp;
      arg1 = INT64_C(2147450879);
      clear_neon_saturated();
      //  Expect: "result" = 000000007fff7fff
      result = vqabsd_s64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = INT64_C(2147450879);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIi64 " Got: %" PRIi64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2642() {

{
   {
      int8x8_t arg1;
      int8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"neg\", fnname = \"vneg_s8\", rettype = \"int8x8_t\", argtypes = \"[int8x8_t]\", vals = [VectorVal [IntegerVal (-128),IntegerVal 127,IntegerVal 84,IntegerVal 127,IntegerVal 127,IntegerVal (-16),IntegerVal 0,IntegerVal (-128)]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s8(UINT64_C(0x8000f07f7f547f80));
      clear_neon_saturated();
      //  Expect: "result" = 8000108181ac8180
      result = vneg_s8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s8(result), 0);
      exp = UINT64_C(0x8000108181ac8180);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2643() {

{
   {
      int16x4_t arg1;
      int16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"neg\", fnname = \"vneg_s16\", rettype = \"int16x4_t\", argtypes = \"[int16x4_t]\", vals = [VectorVal [IntegerVal (-14432),IntegerVal (-1),IntegerVal (-1),IntegerVal 32767]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s16(UINT64_C(0x7fffffffffffc7a0));
      clear_neon_saturated();
      //  Expect: "result" = 8001000100013860
      result = vneg_s16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s16(result), 0);
      exp = UINT64_C(0x8001000100013860);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2644() {

{
   {
      int32x2_t arg1;
      int32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"neg\", fnname = \"vneg_s32\", rettype = \"int32x2_t\", argtypes = \"[int32x2_t]\", vals = [VectorVal [IntegerVal (-977515461),IntegerVal 969146367]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s32(UINT64_C(0x39c3ffffc5bc4c3b));
      clear_neon_saturated();
      //  Expect: "result" = c63c00013a43b3c5
      result = vneg_s32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s32(result), 0);
      exp = UINT64_C(0xc63c00013a43b3c5);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2645() {

{
   {
      float32x2_t arg1;
      float32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"neg\", fnname = \"vneg_f32\", rettype = \"float32x2_t\", argtypes = \"[float32x2_t]\", vals = [VectorVal [FloatVal 0.17157381772994995,FloatVal 0.7395034432411194]], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_f32(UINT64_C(0x3f3d50193e2fb10c));
      clear_neon_saturated();
      //  Expect: "result" = bf3d5019be2fb10c
      result = vneg_f32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result, 0);
         exp = ((float32_t) -0.17157381772994995);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result, 1);
         exp = ((float32_t) -0.7395034432411194);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
   }
}
}
void dotests_2646() {

{
   {
      int8x16_t arg1;
      int8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"neg\", fnname = \"vnegq_s8\", rettype = \"int8x16_t\", argtypes = \"[int8x16_t]\", vals = [VectorVal [IntegerVal 0,IntegerVal (-128),IntegerVal (-128),IntegerVal (-33),IntegerVal (-128),IntegerVal (-128),IntegerVal 0,IntegerVal 127,IntegerVal (-128),IntegerVal (-1),IntegerVal 60,IntegerVal 0,IntegerVal 0,IntegerVal (-1),IntegerVal 103,IntegerVal 0]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s8(vcreate_s8(UINT64_C(0x7f008080df808000)),
                         vcreate_s8(UINT64_C(0x0067ff00003cff80)));
      clear_neon_saturated();
      //  Expect: "result" = 0099010000c401808100808021808000
      result = vnegq_s8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result), 0);
         exp = UINT64_C(0x8100808021808000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result), 1);
         exp = UINT64_C(0x0099010000c40180);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2647() {

{
   {
      int16x8_t arg1;
      int16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"neg\", fnname = \"vnegq_s16\", rettype = \"int16x8_t\", argtypes = \"[int16x8_t]\", vals = [VectorVal [IntegerVal 32767,IntegerVal (-32768),IntegerVal (-1),IntegerVal (-32768),IntegerVal 32767,IntegerVal 0,IntegerVal (-26480),IntegerVal (-1)]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s16(vcreate_s16(UINT64_C(0x8000ffff80007fff)),
                          vcreate_s16(UINT64_C(0xffff989000007fff)));
      clear_neon_saturated();
      //  Expect: "result" = 00016770000080018000000180008001
      result = vnegq_s16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 0);
         exp = UINT64_C(0x8000000180008001);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 1);
         exp = UINT64_C(0x0001677000008001);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2648() {

{
   {
      int32x4_t arg1;
      int32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"neg\", fnname = \"vnegq_s32\", rettype = \"int32x4_t\", argtypes = \"[int32x4_t]\", vals = [VectorVal [IntegerVal (-2147477209),IntegerVal (-2147463808),IntegerVal (-2390),IntegerVal (-2147418113)]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s32(vcreate_s32(UINT64_C(0x80004d8080001927)),
                          vcreate_s32(UINT64_C(0x8000fffffffff6aa)));
      clear_neon_saturated();
      //  Expect: "result" = 7fff0001000009567fffb2807fffe6d9
      result = vnegq_s32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 0);
         exp = UINT64_C(0x7fffb2807fffe6d9);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 1);
         exp = UINT64_C(0x7fff000100000956);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2649() {

{
   {
      float32x4_t arg1;
      float32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"neg\", fnname = \"vnegq_f32\", rettype = \"float32x4_t\", argtypes = \"[float32x4_t]\", vals = [VectorVal [FloatVal 0.1642007827758789,FloatVal 0.15828347206115723,FloatVal 0.5598390698432922,FloatVal 0.6429851651191711]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_f32(vcreate_f32(UINT64_C(0x3e2215103e282440)),
                          vcreate_f32(UINT64_C(0x3f249aad3f0f519d)));
      clear_neon_saturated();
      //  Expect: "result" = bf249aadbf0f519dbe221510be282440
      result = vnegq_f32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 0);
         exp = ((float32_t) -0.1642007827758789);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 1);
         exp = ((float32_t) -0.15828347206115723);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 2);
         exp = ((float32_t) -0.5598390698432922);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 2 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 3);
         exp = ((float32_t) -0.6429851651191711);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 3 ", exp, got);
            }
      }
   }
}
}
void dotests_2650() {

{
   {
      int64x1_t arg1;
      int64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"neg\", fnname = \"vneg_s64\", rettype = \"int64x1_t\", argtypes = \"[int64x1_t]\", vals = [VectorVal [IntegerVal (-9223318589206460035)]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s64(UINT64_C(0x8000309c4017897d));
      clear_neon_saturated();
      //  Expect: "result" = 7fffcf63bfe87683
      result = vneg_s64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s64(result), 0);
      exp = UINT64_C(0x7fffcf63bfe87683);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2651() {

{
   {
      float64x1_t arg1;
      float64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"neg\", fnname = \"vneg_f64\", rettype = \"float64x1_t\", argtypes = \"[float64x1_t]\", vals = [VectorVal [FloatVal 0.14727129785419513]], start_saturated = False}";
      int reported = 0;
      float64_t got;
      float64_t exp;
      arg1 = vcreate_f64(UINT64_C(0x3fc2d9c92ff62cd4));
      clear_neon_saturated();
      //  Expect: "result" = bfc2d9c92ff62cd4
      result = vneg_f64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_f64(result, 0);
      exp = -0.14727129785419513;
      if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
         }
   }
}
}
void dotests_2652() {

{
   {
      int64x2_t arg1;
      int64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"neg\", fnname = \"vnegq_s64\", rettype = \"int64x2_t\", argtypes = \"[int64x2_t]\", vals = [VectorVal [IntegerVal 6086416724452677457,IntegerVal 9223231297218969600]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s64(vcreate_s64(UINT64_C(0x54774bc37fff9751)),
                          vcreate_s64(UINT64_C(0x7fff7fff80008000)));
      clear_neon_saturated();
      //  Expect: "result" = 800080007fff8000ab88b43c800068af
      result = vnegq_s64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 0);
         exp = UINT64_C(0xab88b43c800068af);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 1);
         exp = UINT64_C(0x800080007fff8000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2653() {

{
   {
      float64x2_t arg1;
      float64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"neg\", fnname = \"vnegq_f64\", rettype = \"float64x2_t\", argtypes = \"[float64x2_t]\", vals = [VectorVal [FloatVal 0.7721998923626896,FloatVal 0.4231456233663594]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_f64(vcreate_f64(UINT64_C(0x3fe8b5dc8c7584e4)),
                          vcreate_f64(UINT64_C(0x3fdb14d161737582)));
      clear_neon_saturated();
      //  Expect: "result" = bfdb14d161737582bfe8b5dc8c7584e4
      result = vnegq_f64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float64_t got;
         float64_t exp;
         got = vgetq_lane_f64(result, 0);
         exp = -0.7721998923626896;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float64_t got;
         float64_t exp;
         got = vgetq_lane_f64(result, 1);
         exp = -0.4231456233663594;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
   }
}
}
void dotests_2654() {

{
   {
      int8x8_t arg1;
      int8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"qneg\", fnname = \"vqneg_s8\", rettype = \"int8x8_t\", argtypes = \"[int8x8_t]\", vals = [VectorVal [IntegerVal (-128),IntegerVal 0,IntegerVal (-128),IntegerVal (-1),IntegerVal (-128),IntegerVal 0,IntegerVal 0,IntegerVal (-31)]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s8(UINT64_C(0xe1000080ff800080));
      clear_neon_saturated();
      //  Expect: "result" = 1f00007f017f007f
      result = vqneg_s8(arg1);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s8(result), 0);
      exp = UINT64_C(0x1f00007f017f007f);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2655() {

{
   {
      int16x4_t arg1;
      int16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"qneg\", fnname = \"vqneg_s16\", rettype = \"int16x4_t\", argtypes = \"[int16x4_t]\", vals = [VectorVal [IntegerVal 0,IntegerVal (-32768),IntegerVal (-23903),IntegerVal 32767]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s16(UINT64_C(0x7fffa2a180000000));
      clear_neon_saturated();
      //  Expect: "result" = 80015d5f7fff0000
      result = vqneg_s16(arg1);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s16(result), 0);
      exp = UINT64_C(0x80015d5f7fff0000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2656() {

{
   {
      int32x2_t arg1;
      int32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"qneg\", fnname = \"vqneg_s32\", rettype = \"int32x2_t\", argtypes = \"[int32x2_t]\", vals = [VectorVal [IntegerVal 2147450879,IntegerVal 18401]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s32(UINT64_C(0x000047e17fff7fff));
      clear_neon_saturated();
      //  Expect: "result" = ffffb81f80008001
      result = vqneg_s32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s32(result), 0);
      exp = UINT64_C(0xffffb81f80008001);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2657() {

{
   {
      int8x16_t arg1;
      int8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"qneg\", fnname = \"vqnegq_s8\", rettype = \"int8x16_t\", argtypes = \"[int8x16_t]\", vals = [VectorVal [IntegerVal 127,IntegerVal (-31),IntegerVal (-128),IntegerVal (-128),IntegerVal 0,IntegerVal 127,IntegerVal 0,IntegerVal (-1),IntegerVal (-128),IntegerVal (-55),IntegerVal 112,IntegerVal 127,IntegerVal (-128),IntegerVal 0,IntegerVal (-128),IntegerVal 127]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s8(vcreate_s8(UINT64_C(0xff007f008080e17f)),
                         vcreate_s8(UINT64_C(0x7f8000807f70c980)));
      clear_neon_saturated();
      //  Expect: "result" = 817f007f8190377f010081007f7f1f81
      result = vqnegq_s8(arg1);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result), 0);
         exp = UINT64_C(0x010081007f7f1f81);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result), 1);
         exp = UINT64_C(0x817f007f8190377f);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2658() {

{
   {
      int16x8_t arg1;
      int16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"qneg\", fnname = \"vqnegq_s16\", rettype = \"int16x8_t\", argtypes = \"[int16x8_t]\", vals = [VectorVal [IntegerVal 32767,IntegerVal (-1),IntegerVal (-1),IntegerVal (-32768),IntegerVal (-1),IntegerVal 32767,IntegerVal (-32768),IntegerVal 32767]], start_saturated = True}";
      int reported = 0;
      arg1 = vcombine_s16(vcreate_s16(UINT64_C(0x8000ffffffff7fff)),
                          vcreate_s16(UINT64_C(0x7fff80007fffffff)));
      set_neon_saturated();
      //  Expect: "result" = 80017fff800100017fff000100018001
      result = vqnegq_s16(arg1);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 0);
         exp = UINT64_C(0x7fff000100018001);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 1);
         exp = UINT64_C(0x80017fff80010001);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2659() {

{
   {
      int32x4_t arg1;
      int32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"qneg\", fnname = \"vqnegq_s32\", rettype = \"int32x4_t\", argtypes = \"[int32x4_t]\", vals = [VectorVal [IntegerVal (-2147483648),IntegerVal (-2147483648),IntegerVal (-2147483648),IntegerVal 206307328]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s32(vcreate_s32(UINT64_C(0x8000000080000000)),
                          vcreate_s32(UINT64_C(0x0c4c000080000000)));
      clear_neon_saturated();
      //  Expect: "result" = f3b400007fffffff7fffffff7fffffff
      result = vqnegq_s32(arg1);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 0);
         exp = UINT64_C(0x7fffffff7fffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 1);
         exp = UINT64_C(0xf3b400007fffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2660() {

{
   {
      int64x1_t arg1;
      int64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"qneg\", fnname = \"vqneg_s64\", rettype = \"int64x1_t\", argtypes = \"[int64x1_t]\", vals = [VectorVal [IntegerVal 2147516415]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s64(UINT64_C(0x0000000080007fff));
      clear_neon_saturated();
      //  Expect: "result" = ffffffff7fff8001
      result = vqneg_s64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s64(result), 0);
      exp = UINT64_C(0xffffffff7fff8001);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2661() {

{
   {
      int64x2_t arg1;
      int64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"qneg\", fnname = \"vqnegq_s64\", rettype = \"int64x2_t\", argtypes = \"[int64x2_t]\", vals = [VectorVal [IntegerVal (-9223090566172999681),IntegerVal (-140737488420864)]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s64(vcreate_s64(UINT64_C(0x8000ffff00007fff)),
                          vcreate_s64(UINT64_C(0xffff7fffffff0000)));
      clear_neon_saturated();
      //  Expect: "result" = 00008000000100007fff0000ffff8001
      result = vqnegq_s64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 0);
         exp = UINT64_C(0x7fff0000ffff8001);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 1);
         exp = UINT64_C(0x0000800000010000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2662() {

{
   {
      int8_t arg1;
      int8_t result;
      char* str1 = "ReproInfo2 {semantics = \"qneg\", fnname = \"vqnegb_s8\", rettype = \"int8_t\", argtypes = \"[int8_t]\", vals = [IntegerVal 0], start_saturated = False}";
      int reported = 0;
      int8_t got;
      int8_t exp;
      arg1 = 0;
      clear_neon_saturated();
      //  Expect: "result" = 00
      result = vqnegb_s8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = 0;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2663() {

{
   {
      int16_t arg1;
      int16_t result;
      char* str1 = "ReproInfo2 {semantics = \"qneg\", fnname = \"vqnegh_s16\", rettype = \"int16_t\", argtypes = \"[int16_t]\", vals = [IntegerVal 12516], start_saturated = False}";
      int reported = 0;
      int16_t got;
      int16_t exp;
      arg1 = 12516;
      clear_neon_saturated();
      //  Expect: "result" = cf1c
      result = vqnegh_s16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = -12516;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIi16 " Got: %" PRIi16 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2664() {

{
   {
      int32_t arg1;
      int32_t result;
      char* str1 = "ReproInfo2 {semantics = \"qneg\", fnname = \"vqnegs_s32\", rettype = \"int32_t\", argtypes = \"[int32_t]\", vals = [IntegerVal 32768], start_saturated = False}";
      int reported = 0;
      int32_t got;
      int32_t exp;
      arg1 = 32768;
      clear_neon_saturated();
      //  Expect: "result" = ffff8000
      result = vqnegs_s32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = -32768;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIi32 " Got: %" PRIi32 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2665() {

{
   {
      int64_t arg1;
      int64_t result;
      char* str1 = "ReproInfo2 {semantics = \"qneg\", fnname = \"vqnegd_s64\", rettype = \"int64_t\", argtypes = \"[int64_t]\", vals = [IntegerVal 1723334655], start_saturated = False}";
      int reported = 0;
      int64_t got;
      int64_t exp;
      arg1 = INT64_C(1723334655);
      clear_neon_saturated();
      //  Expect: "result" = ffffffff99480001
      result = vqnegd_s64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = INT64_C(-1723334655);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIi64 " Got: %" PRIi64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2666() {

{
   {
      int8x8_t arg1;
      int8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"cls\", fnname = \"vcls_s8\", rettype = \"int8x8_t\", argtypes = \"[int8x8_t]\", vals = [VectorVal [IntegerVal 70,IntegerVal (-52),IntegerVal (-1),IntegerVal 81,IntegerVal (-128),IntegerVal (-123),IntegerVal (-65),IntegerVal (-1)]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s8(UINT64_C(0xffbf858051ffcc46));
      clear_neon_saturated();
      //  Expect: "result" = 0700000000070100
      result = vcls_s8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s8(result), 0);
      exp = UINT64_C(0x0700000000070100);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2667() {

{
   {
      int16x4_t arg1;
      int16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"cls\", fnname = \"vcls_s16\", rettype = \"int16x4_t\", argtypes = \"[int16x4_t]\", vals = [VectorVal [IntegerVal (-11181),IntegerVal 23280,IntegerVal 0,IntegerVal (-1)]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s16(UINT64_C(0xffff00005af0d453));
      clear_neon_saturated();
      //  Expect: "result" = 000f000f00000001
      result = vcls_s16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s16(result), 0);
      exp = UINT64_C(0x000f000f00000001);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2668() {

{
   {
      int32x2_t arg1;
      int32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"cls\", fnname = \"vcls_s32\", rettype = \"int32x2_t\", argtypes = \"[int32x2_t]\", vals = [VectorVal [IntegerVal 32767,IntegerVal (-2147418113)]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s32(UINT64_C(0x8000ffff00007fff));
      clear_neon_saturated();
      //  Expect: "result" = 0000000000000010
      result = vcls_s32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s32(result), 0);
      exp = UINT64_C(0x0000000000000010);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2669() {

{
   {
      int8x16_t arg1;
      int8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"cls\", fnname = \"vclsq_s8\", rettype = \"int8x16_t\", argtypes = \"[int8x16_t]\", vals = [VectorVal [IntegerVal 51,IntegerVal 0,IntegerVal (-1),IntegerVal (-1),IntegerVal 98,IntegerVal 0,IntegerVal (-1),IntegerVal (-56),IntegerVal 127,IntegerVal (-128),IntegerVal 66,IntegerVal (-128),IntegerVal (-128),IntegerVal (-128),IntegerVal 99,IntegerVal (-1)]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s8(vcreate_s8(UINT64_C(0xc8ff0062ffff0033)),
                         vcreate_s8(UINT64_C(0xff6380808042807f)));
      clear_neon_saturated();
      //  Expect: "result" = 07000000000000000107070007070701
      result = vclsq_s8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result), 0);
         exp = UINT64_C(0x0107070007070701);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result), 1);
         exp = UINT64_C(0x0700000000000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2670() {

{
   {
      int16x8_t arg1;
      int16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"cls\", fnname = \"vclsq_s16\", rettype = \"int16x8_t\", argtypes = \"[int16x8_t]\", vals = [VectorVal [IntegerVal (-1),IntegerVal (-32768),IntegerVal 21367,IntegerVal (-29651),IntegerVal (-1),IntegerVal (-1),IntegerVal 0,IntegerVal 26369]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s16(vcreate_s16(UINT64_C(0x8c2d53778000ffff)),
                          vcreate_s16(UINT64_C(0x67010000ffffffff)));
      clear_neon_saturated();
      //  Expect: "result" = 0000000f000f000f000000000000000f
      result = vclsq_s16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 0);
         exp = UINT64_C(0x000000000000000f);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 1);
         exp = UINT64_C(0x0000000f000f000f);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2671() {

{
   {
      int32x4_t arg1;
      int32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"cls\", fnname = \"vclsq_s32\", rettype = \"int32x4_t\", argtypes = \"[int32x4_t]\", vals = [VectorVal [IntegerVal (-1396437144),IntegerVal 2147450880,IntegerVal 0,IntegerVal 65535]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s32(vcreate_s32(UINT64_C(0x7fff8000acc40f68)),
                          vcreate_s32(UINT64_C(0x0000ffff00000000)));
      clear_neon_saturated();
      //  Expect: "result" = 0000000f0000001f0000000000000000
      result = vclsq_s32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 0);
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 1);
         exp = UINT64_C(0x0000000f0000001f);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2672() {

{
   {
      int8x8_t arg1;
      int8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"clz\", fnname = \"vclz_s8\", rettype = \"int8x8_t\", argtypes = \"[int8x8_t]\", vals = [VectorVal [IntegerVal (-1),IntegerVal 100,IntegerVal (-1),IntegerVal (-1),IntegerVal (-1),IntegerVal 0,IntegerVal 127,IntegerVal 35]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s8(UINT64_C(0x237f00ffffff64ff));
      clear_neon_saturated();
      //  Expect: "result" = 0201080000000100
      result = vclz_s8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s8(result), 0);
      exp = UINT64_C(0x0201080000000100);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2673() {

{
   {
      int16x4_t arg1;
      int16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"clz\", fnname = \"vclz_s16\", rettype = \"int16x4_t\", argtypes = \"[int16x4_t]\", vals = [VectorVal [IntegerVal (-1),IntegerVal (-32768),IntegerVal (-32768),IntegerVal (-1)]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s16(UINT64_C(0xffff80008000ffff));
      clear_neon_saturated();
      //  Expect: "result" = 0000000000000000
      result = vclz_s16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s16(result), 0);
      exp = 0;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2674() {

{
   {
      int32x2_t arg1;
      int32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"clz\", fnname = \"vclz_s32\", rettype = \"int32x2_t\", argtypes = \"[int32x2_t]\", vals = [VectorVal [IntegerVal (-31969),IntegerVal 2147450880]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s32(UINT64_C(0x7fff8000ffff831f));
      clear_neon_saturated();
      //  Expect: "result" = 0000000100000000
      result = vclz_s32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s32(result), 0);
      exp = UINT64_C(0x0000000100000000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2675() {

{
   {
      uint8x8_t arg1;
      uint8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"clz\", fnname = \"vclz_u8\", rettype = \"uint8x8_t\", argtypes = \"[uint8x8_t]\", vals = [VectorVal [IntegerVal 128,IntegerVal 128,IntegerVal 128,IntegerVal 128,IntegerVal 127,IntegerVal 76,IntegerVal 139,IntegerVal 220]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u8(UINT64_C(0xdc8b4c7f80808080));
      clear_neon_saturated();
      //  Expect: "result" = 0000010100000000
      result = vclz_u8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u8(result), 0);
      exp = UINT64_C(0x0000010100000000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2676() {

{
   {
      uint16x4_t arg1;
      uint16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"clz\", fnname = \"vclz_u16\", rettype = \"uint16x4_t\", argtypes = \"[uint16x4_t]\", vals = [VectorVal [IntegerVal 32767,IntegerVal 24507,IntegerVal 65535,IntegerVal 32768]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u16(UINT64_C(0x8000ffff5fbb7fff));
      clear_neon_saturated();
      //  Expect: "result" = 0000000000010001
      result = vclz_u16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u16(result), 0);
      exp = UINT64_C(0x0000000000010001);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2677() {

{
   {
      uint32x2_t arg1;
      uint32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"clz\", fnname = \"vclz_u32\", rettype = \"uint32x2_t\", argtypes = \"[uint32x2_t]\", vals = [VectorVal [IntegerVal 2147516415,IntegerVal 32768]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u32(UINT64_C(0x0000800080007fff));
      clear_neon_saturated();
      //  Expect: "result" = 0000001000000000
      result = vclz_u32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u32(result), 0);
      exp = UINT64_C(0x0000001000000000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2678() {

{
   {
      int8x16_t arg1;
      int8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"clz\", fnname = \"vclzq_s8\", rettype = \"int8x16_t\", argtypes = \"[int8x16_t]\", vals = [VectorVal [IntegerVal (-128),IntegerVal (-1),IntegerVal (-1),IntegerVal (-128),IntegerVal (-128),IntegerVal 0,IntegerVal 0,IntegerVal (-1),IntegerVal 127,IntegerVal 127,IntegerVal (-1),IntegerVal 0,IntegerVal 26,IntegerVal (-128),IntegerVal (-1),IntegerVal 107]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s8(vcreate_s8(UINT64_C(0xff00008080ffff80)),
                         vcreate_s8(UINT64_C(0x6bff801a00ff7f7f)));
      clear_neon_saturated();
      //  Expect: "result" = 01000003080001010008080000000000
      result = vclzq_s8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result), 0);
         exp = UINT64_C(0x0008080000000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result), 1);
         exp = UINT64_C(0x0100000308000101);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2679() {

{
   {
      int16x8_t arg1;
      int16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"clz\", fnname = \"vclzq_s16\", rettype = \"int16x8_t\", argtypes = \"[int16x8_t]\", vals = [VectorVal [IntegerVal 21404,IntegerVal (-1),IntegerVal (-32768),IntegerVal (-26747),IntegerVal 26735,IntegerVal 32767,IntegerVal 0,IntegerVal (-6662)]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s16(vcreate_s16(UINT64_C(0x97858000ffff539c)),
                          vcreate_s16(UINT64_C(0xe5fa00007fff686f)));
      clear_neon_saturated();
      //  Expect: "result" = 00000010000100010000000000000001
      result = vclzq_s16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 0);
         exp = UINT64_C(0x0000000000000001);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 1);
         exp = UINT64_C(0x0000001000010001);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2680() {

{
   {
      int32x4_t arg1;
      int32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"clz\", fnname = \"vclzq_s32\", rettype = \"int32x4_t\", argtypes = \"[int32x4_t]\", vals = [VectorVal [IntegerVal (-65536),IntegerVal (-2147418113),IntegerVal 1896447999,IntegerVal 2147450879]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s32(vcreate_s32(UINT64_C(0x8000ffffffff0000)),
                          vcreate_s32(UINT64_C(0x7fff7fff71097fff)));
      clear_neon_saturated();
      //  Expect: "result" = 00000001000000010000000000000000
      result = vclzq_s32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 0);
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 1);
         exp = UINT64_C(0x0000000100000001);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2681() {

{
   {
      uint8x16_t arg1;
      uint8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"clz\", fnname = \"vclzq_u8\", rettype = \"uint8x16_t\", argtypes = \"[uint8x16_t]\", vals = [VectorVal [IntegerVal 187,IntegerVal 15,IntegerVal 255,IntegerVal 0,IntegerVal 80,IntegerVal 0,IntegerVal 128,IntegerVal 192,IntegerVal 255,IntegerVal 255,IntegerVal 128,IntegerVal 145,IntegerVal 127,IntegerVal 127,IntegerVal 0,IntegerVal 0]], start_saturated = True}";
      int reported = 0;
      arg1 = vcombine_u8(vcreate_u8(UINT64_C(0xc080005000ff0fbb)),
                         vcreate_u8(UINT64_C(0x00007f7f9180ffff)));
      set_neon_saturated();
      //  Expect: "result" = 08080101000000000000080108000400
      result = vclzq_u8(arg1);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 0);
         exp = UINT64_C(0x0000080108000400);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 1);
         exp = UINT64_C(0x0808010100000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2682() {

{
   {
      uint16x8_t arg1;
      uint16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"clz\", fnname = \"vclzq_u16\", rettype = \"uint16x8_t\", argtypes = \"[uint16x8_t]\", vals = [VectorVal [IntegerVal 32768,IntegerVal 32767,IntegerVal 49357,IntegerVal 65535,IntegerVal 32767,IntegerVal 32767,IntegerVal 32767,IntegerVal 8116]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u16(vcreate_u16(UINT64_C(0xffffc0cd7fff8000)),
                          vcreate_u16(UINT64_C(0x1fb47fff7fff7fff)));
      clear_neon_saturated();
      //  Expect: "result" = 00030001000100010000000000010000
      result = vclzq_u16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 0);
         exp = UINT64_C(0x0000000000010000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 1);
         exp = UINT64_C(0x0003000100010001);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2683() {

{
   {
      uint32x4_t arg1;
      uint32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"clz\", fnname = \"vclzq_u32\", rettype = \"uint32x4_t\", argtypes = \"[uint32x4_t]\", vals = [VectorVal [IntegerVal 2147450606,IntegerVal 4294901760,IntegerVal 0,IntegerVal 4294940868]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u32(vcreate_u32(UINT64_C(0xffff00007fff7eee)),
                          vcreate_u32(UINT64_C(0xffff98c400000000)));
      clear_neon_saturated();
      //  Expect: "result" = 00000000000000200000000000000001
      result = vclzq_u32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 0);
         exp = UINT64_C(0x0000000000000001);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 1);
         exp = UINT64_C(0x0000000000000020);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2684() {

{
   {
      uint8x8_t arg1;
      uint8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"cnt\", fnname = \"vcnt_u8\", rettype = \"uint8x8_t\", argtypes = \"[uint8x8_t]\", vals = [VectorVal [IntegerVal 255,IntegerVal 127,IntegerVal 255,IntegerVal 27,IntegerVal 128,IntegerVal 7,IntegerVal 127,IntegerVal 0]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u8(UINT64_C(0x007f07801bff7fff));
      clear_neon_saturated();
      //  Expect: "result" = 0007030104080708
      result = vcnt_u8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u8(result), 0);
      exp = UINT64_C(0x0007030104080708);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2685() {

{
   {
      int8x8_t arg1;
      int8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"cnt\", fnname = \"vcnt_s8\", rettype = \"int8x8_t\", argtypes = \"[int8x8_t]\", vals = [VectorVal [IntegerVal (-128),IntegerVal 127,IntegerVal (-90),IntegerVal (-128),IntegerVal 0,IntegerVal (-1),IntegerVal 127,IntegerVal (-128)]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s8(UINT64_C(0x807fff0080a67f80));
      clear_neon_saturated();
      //  Expect: "result" = 0107080001040701
      result = vcnt_s8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s8(result), 0);
      exp = UINT64_C(0x0107080001040701);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2686() {

{
   {
      poly8x8_t arg1;
      poly8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"cnt\", fnname = \"vcnt_p8\", rettype = \"poly8x8_t\", argtypes = \"[poly8x8_t]\", vals = [VectorVal [PolyVal [1,1,1,1,0,1,1,0],PolyVal [0,1,0,1,0,0,0,0],PolyVal [1,1,0,1,1,0,0,0],PolyVal [0,1,1,0,0,1,1,1],PolyVal [1,0,0,1,0,1,1,0],PolyVal [0,1,0,1,1,0,1,1],PolyVal [0,1,0,0,1,1,0,1],PolyVal [1,1,0,0,1,1,0,1]]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_p8(UINT64_C(0xb3b2da69e61b0a6f));
      clear_neon_saturated();
      //  Expect: "result" = 0504050405040206
      result = vcnt_p8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_p8(result), 0);
      exp = UINT64_C(0x0504050405040206);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2687() {

{
   {
      uint8x16_t arg1;
      uint8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"cnt\", fnname = \"vcntq_u8\", rettype = \"uint8x16_t\", argtypes = \"[uint8x16_t]\", vals = [VectorVal [IntegerVal 255,IntegerVal 127,IntegerVal 127,IntegerVal 128,IntegerVal 127,IntegerVal 0,IntegerVal 0,IntegerVal 127,IntegerVal 127,IntegerVal 128,IntegerVal 128,IntegerVal 127,IntegerVal 37,IntegerVal 159,IntegerVal 128,IntegerVal 127]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u8(vcreate_u8(UINT64_C(0x7f00007f807f7fff)),
                         vcreate_u8(UINT64_C(0x7f809f257f80807f)));
      clear_neon_saturated();
      //  Expect: "result" = 07010603070101070700000701070708
      result = vcntq_u8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 0);
         exp = UINT64_C(0x0700000701070708);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 1);
         exp = UINT64_C(0x0701060307010107);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2688() {

{
   {
      int8x16_t arg1;
      int8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"cnt\", fnname = \"vcntq_s8\", rettype = \"int8x16_t\", argtypes = \"[int8x16_t]\", vals = [VectorVal [IntegerVal 127,IntegerVal (-128),IntegerVal 0,IntegerVal 127,IntegerVal (-128),IntegerVal (-128),IntegerVal 127,IntegerVal 0,IntegerVal 127,IntegerVal 127,IntegerVal (-100),IntegerVal (-1),IntegerVal 127,IntegerVal (-128),IntegerVal 108,IntegerVal (-31)]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s8(vcreate_s8(UINT64_C(0x007f80807f00807f)),
                         vcreate_s8(UINT64_C(0xe16c807fff9c7f7f)));
      clear_neon_saturated();
      //  Expect: "result" = 04040107080407070007010107000107
      result = vcntq_s8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result), 0);
         exp = UINT64_C(0x0007010107000107);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result), 1);
         exp = UINT64_C(0x0404010708040707);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2689() {

{
   {
      poly8x16_t arg1;
      poly8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"cnt\", fnname = \"vcntq_p8\", rettype = \"poly8x16_t\", argtypes = \"[poly8x16_t]\", vals = [VectorVal [PolyVal [1,0,1,0,1,1,1,0],PolyVal [1,1,0,0,0,1,0,0],PolyVal [0,1,0,0,1,1,1,1],PolyVal [0,0,0,0,1,1,1,0],PolyVal [0,0,0,0,0,1,0,1],PolyVal [1,0,0,1,0,1,1,0],PolyVal [0,1,1,1,0,1,0,0],PolyVal [1,0,0,1,0,1,1,1],PolyVal [0,1,0,1,1,0,1,0],PolyVal [0,0,0,1,1,1,1,0],PolyVal [1,0,0,1,0,0,0,0],PolyVal [0,1,1,0,1,1,1,1],PolyVal [1,0,1,1,1,0,1,0],PolyVal [1,1,1,0,0,0,0,1],PolyVal [1,1,0,0,1,1,1,0],PolyVal [0,1,1,0,0,1,0,1]]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_p8(vcreate_p8(UINT64_C(0xe92e69a070f22375)),
                         vcreate_p8(UINT64_C(0xa673875df609785a)));
      clear_neon_saturated();
      //  Expect: "result" = 04050405060204040504040203050305
      result = vcntq_p8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p8(result), 0);
         exp = UINT64_C(0x0504040203050305);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p8(result), 1);
         exp = UINT64_C(0x0405040506020404);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2690() {

{
   {
      uint8x8_t arg1;
      uint8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"rbit\", fnname = \"vrbit_u8\", rettype = \"uint8x8_t\", argtypes = \"[uint8x8_t]\", vals = [VectorVal [IntegerVal 128,IntegerVal 0,IntegerVal 255,IntegerVal 161,IntegerVal 0,IntegerVal 255,IntegerVal 0,IntegerVal 128]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u8(UINT64_C(0x8000ff00a1ff0080));
      clear_neon_saturated();
      //  Expect: "result" = 0100ff0085ff0001
      result = vrbit_u8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u8(result), 0);
      exp = UINT64_C(0x0100ff0085ff0001);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2691() {

{
   {
      int8x8_t arg1;
      int8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"rbit\", fnname = \"vrbit_s8\", rettype = \"int8x8_t\", argtypes = \"[int8x8_t]\", vals = [VectorVal [IntegerVal (-1),IntegerVal 127,IntegerVal 127,IntegerVal 0,IntegerVal (-1),IntegerVal 0,IntegerVal (-128),IntegerVal 126]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s8(UINT64_C(0x7e8000ff007f7fff));
      clear_neon_saturated();
      //  Expect: "result" = 7e0100ff00fefeff
      result = vrbit_s8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s8(result), 0);
      exp = UINT64_C(0x7e0100ff00fefeff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2692() {

{
   {
      poly8x8_t arg1;
      poly8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"rbit\", fnname = \"vrbit_p8\", rettype = \"poly8x8_t\", argtypes = \"[poly8x8_t]\", vals = [VectorVal [PolyVal [0,1,0,0,1,0,1,1],PolyVal [0,0,1,1,0,1,1,0],PolyVal [1,0,0,1,1,1,0,1],PolyVal [0,1,1,0,0,0,0,1],PolyVal [1,0,1,1,0,0,0,1],PolyVal [1,0,0,1,0,1,0,1],PolyVal [1,1,1,0,1,0,1,0],PolyVal [0,0,0,0,0,1,1,1]]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_p8(UINT64_C(0xe057a98d86b96cd2));
      clear_neon_saturated();
      //  Expect: "result" = 07ea95b1619d364b
      result = vrbit_p8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_p8(result), 0);
      exp = UINT64_C(0x07ea95b1619d364b);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2693() {

{
   {
      uint8x16_t arg1;
      uint8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"rbit\", fnname = \"vrbitq_u8\", rettype = \"uint8x16_t\", argtypes = \"[uint8x16_t]\", vals = [VectorVal [IntegerVal 127,IntegerVal 0,IntegerVal 255,IntegerVal 127,IntegerVal 65,IntegerVal 17,IntegerVal 223,IntegerVal 172,IntegerVal 127,IntegerVal 0,IntegerVal 255,IntegerVal 255,IntegerVal 128,IntegerVal 127,IntegerVal 127,IntegerVal 60]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u8(vcreate_u8(UINT64_C(0xacdf11417fff007f)),
                         vcreate_u8(UINT64_C(0x3c7f7f80ffff007f)));
      clear_neon_saturated();
      //  Expect: "result" = 3cfefe01ffff00fe35fb8882feff00fe
      result = vrbitq_u8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 0);
         exp = UINT64_C(0x35fb8882feff00fe);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 1);
         exp = UINT64_C(0x3cfefe01ffff00fe);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2694() {

{
   {
      int8x16_t arg1;
      int8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"rbit\", fnname = \"vrbitq_s8\", rettype = \"int8x16_t\", argtypes = \"[int8x16_t]\", vals = [VectorVal [IntegerVal (-128),IntegerVal (-1),IntegerVal (-1),IntegerVal (-128),IntegerVal (-1),IntegerVal (-1),IntegerVal 0,IntegerVal 40,IntegerVal 0,IntegerVal 127,IntegerVal 0,IntegerVal 127,IntegerVal (-1),IntegerVal 127,IntegerVal (-128),IntegerVal (-61)]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s8(vcreate_s8(UINT64_C(0x2800ffff80ffff80)),
                         vcreate_s8(UINT64_C(0xc3807fff7f007f00)));
      clear_neon_saturated();
      //  Expect: "result" = c301fefffe00fe001400ffff01ffff01
      result = vrbitq_s8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result), 0);
         exp = UINT64_C(0x1400ffff01ffff01);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result), 1);
         exp = UINT64_C(0xc301fefffe00fe00);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2695() {

{
   {
      poly8x16_t arg1;
      poly8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"rbit\", fnname = \"vrbitq_p8\", rettype = \"poly8x16_t\", argtypes = \"[poly8x16_t]\", vals = [VectorVal [PolyVal [1,0,0,1,0,0,0,1],PolyVal [0,0,1,1,0,0,1,1],PolyVal [0,1,0,0,0,0,0,1],PolyVal [1,1,1,0,0,0,1,0],PolyVal [1,0,1,0,1,1,0,1],PolyVal [0,1,1,0,0,1,1,0],PolyVal [0,0,0,0,0,1,0,0],PolyVal [0,1,0,1,1,0,1,1],PolyVal [1,1,1,1,0,0,1,1],PolyVal [1,1,0,1,0,0,0,1],PolyVal [1,0,1,0,0,0,1,0],PolyVal [0,1,0,1,1,0,0,1],PolyVal [0,0,0,1,0,0,1,1],PolyVal [0,0,1,1,0,0,0,1],PolyVal [1,0,0,0,1,0,0,0],PolyVal [0,1,1,0,1,1,0,1]]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_p8(vcreate_p8(UINT64_C(0xda2066b54782cc89)),
                         vcreate_p8(UINT64_C(0xb6118cc89a458bcf)));
      clear_neon_saturated();
      //  Expect: "result" = 6d88311359a2d1f35b0466ade2413391
      result = vrbitq_p8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p8(result), 0);
         exp = UINT64_C(0x5b0466ade2413391);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p8(result), 1);
         exp = UINT64_C(0x6d88311359a2d1f3);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2696() {

{
   {
      float32x2_t arg1;
      float32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"recpe\", fnname = \"vrecpe_f32\", rettype = \"float32x2_t\", argtypes = \"[float32x2_t]\", vals = [VectorVal [FloatVal 0.7353664040565491,FloatVal 0.9716883897781372]], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_f32(UINT64_C(0x3f78c0923f3c40f9));
      clear_neon_saturated();
      //  Expect: "result" = 3f8380003fae0000
      result = vrecpe_f32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result, 0);
         exp = ((float32_t) 1.359375);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result, 1);
         exp = ((float32_t) 1.02734375);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
   }
}
}
void dotests_2697() {

{
   {
      uint32x2_t arg1;
      uint32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"recpe\", fnname = \"vrecpe_u32\", rettype = \"uint32x2_t\", argtypes = \"[uint32x2_t]\", vals = [VectorVal [IntegerVal 2147524265,IntegerVal 65535]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u32(UINT64_C(0x0000ffff80009ea9));
      clear_neon_saturated();
      //  Expect: "result" = ffffffffff800000
      result = vrecpe_u32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u32(result), 0);
      exp = UINT64_C(0xffffffffff800000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2698() {

{
   {
      float32x4_t arg1;
      float32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"recpe\", fnname = \"vrecpeq_f32\", rettype = \"float32x4_t\", argtypes = \"[float32x4_t]\", vals = [VectorVal [FloatVal 0.769888162612915,FloatVal 0.9911182522773743,FloatVal 0.8797654509544373,FloatVal 0.7001799941062927]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_f32(vcreate_f32(UINT64_C(0x3f7db9ed3f451764)),
                          vcreate_f32(UINT64_C(0x3f333eff3f61384f)));
      clear_neon_saturated();
      //  Expect: "result" = 3fb700003f9180003f8100003fa60000
      result = vrecpeq_f32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 0);
         exp = ((float32_t) 1.296875);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 1);
         exp = ((float32_t) 1.0078125);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 2);
         exp = ((float32_t) 1.13671875);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 2 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 3);
         exp = ((float32_t) 1.4296875);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 3 ", exp, got);
            }
      }
   }
}
}
void dotests_2699() {

{
   {
      uint32x4_t arg1;
      uint32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"recpe\", fnname = \"vrecpeq_u32\", rettype = \"uint32x4_t\", argtypes = \"[uint32x4_t]\", vals = [VectorVal [IntegerVal 4294934528,IntegerVal 3206250495,IntegerVal 2863792127,IntegerVal 2147516415]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u32(vcreate_u32(UINT64_C(0xbf1b7fffffff8000)),
                          vcreate_u32(UINT64_C(0x80007fffaab1ffff)));
      clear_neon_saturated();
      //  Expect: "result" = ff800000c0000000ab80000080000000
      result = vrecpeq_u32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 0);
         exp = UINT64_C(0xab80000080000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 1);
         exp = UINT64_C(0xff800000c0000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2700() {

{
   {
      float64x1_t arg1;
      float64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"recpe\", fnname = \"vrecpe_f64\", rettype = \"float64x1_t\", argtypes = \"[float64x1_t]\", vals = [VectorVal [FloatVal 0.8154592355750026]], start_saturated = False}";
      int reported = 0;
      float64_t got;
      float64_t exp;
      arg1 = vcreate_f64(UINT64_C(0x3fea183df7808166));
      clear_neon_saturated();
      //  Expect: "result" = 3ff3a00000000000
      result = vrecpe_f64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_f64(result, 0);
      exp = 1.2265625;
      if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
         }
   }
}
}
void dotests_2701() {

{
   {
      float64x2_t arg1;
      float64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"recpe\", fnname = \"vrecpeq_f64\", rettype = \"float64x2_t\", argtypes = \"[float64x2_t]\", vals = [VectorVal [FloatVal 0.3972102712326069,FloatVal 0.5348282628502871]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_f64(vcreate_f64(UINT64_C(0x3fd96be4a12513d8)),
                          vcreate_f64(UINT64_C(0x3fe11d50293d6425)));
      clear_neon_saturated();
      //  Expect: "result" = 3ffdf000000000004004200000000000
      result = vrecpeq_f64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float64_t got;
         float64_t exp;
         got = vgetq_lane_f64(result, 0);
         exp = 2.515625;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float64_t got;
         float64_t exp;
         got = vgetq_lane_f64(result, 1);
         exp = 1.87109375;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
   }
}
}
void dotests_2702() {

{
   {
      float32_t arg1;
      float32_t result;
      char* str1 = "ReproInfo2 {semantics = \"recpe\", fnname = \"vrecpes_f32\", rettype = \"float32_t\", argtypes = \"[float32_t]\", vals = [FloatVal 0.6703985929489136], start_saturated = False}";
      int reported = 0;
      float32_t got;
      float32_t exp;
      arg1 = ((float32_t) 0.6703985929489136);
      clear_neon_saturated();
      //  Expect: "result" = 3fbf0000
      result = vrecpes_f32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = ((float32_t) 1.4921875);
      if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %f Got: %f\n", "   ", exp, got);
         }
   }
}
}
void dotests_2703() {

{
   {
      float64_t arg1;
      float64_t result;
      char* str1 = "ReproInfo2 {semantics = \"recpe\", fnname = \"vrecped_f64\", rettype = \"float64_t\", argtypes = \"[float64_t]\", vals = [FloatVal 0.7252571309571285], start_saturated = False}";
      int reported = 0;
      float64_t got;
      float64_t exp;
      arg1 = 0.7252571309571285;
      clear_neon_saturated();
      //  Expect: "result" = 3ff6100000000000
      result = vrecped_f64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = 1.37890625;
      if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %f Got: %f\n", "   ", exp, got);
         }
   }
}
}
void dotests_2704() {

{
   
}
}
void dotests_2705() {

{
   
}
}
void dotests_2706() {

{
   {
      float32x2_t arg1;
      float32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"rsqrte\", fnname = \"vrsqrte_f32\", rettype = \"float32x2_t\", argtypes = \"[float32x2_t]\", vals = [VectorVal [FloatVal 3.2218217849731445e-2,FloatVal 0.6526968479156494]], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_f32(UINT64_C(0x3f2717243d03f740));
      clear_neon_saturated();
      //  Expect: "result" = 3f9e000040b28000
      result = vrsqrte_f32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result, 0);
         exp = ((float32_t) 5.578125);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result, 1);
         exp = ((float32_t) 1.234375);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
   }
}
}
void dotests_2707() {

{
   {
      uint32x2_t arg1;
      uint32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"rsqrte\", fnname = \"vrsqrte_u32\", rettype = \"uint32x2_t\", argtypes = \"[uint32x2_t]\", vals = [VectorVal [IntegerVal 1872723967,IntegerVal 266436608]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u32(UINT64_C(0x0fe180006f9f7fff));
      clear_neon_saturated();
      //  Expect: "result" = ffffffffc1800000
      result = vrsqrte_u32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u32(result), 0);
      exp = UINT64_C(0xffffffffc1800000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2708() {

{
   {
      float32x4_t arg1;
      float32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"rsqrte\", fnname = \"vrsqrteq_f32\", rettype = \"float32x4_t\", argtypes = \"[float32x4_t]\", vals = [VectorVal [FloatVal 0.653863787651062,FloatVal 0.46208012104034424,FloatVal 0.47300148010253906,FloatVal 0.8095714449882507]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_f32(vcreate_f32(UINT64_C(0x3eec95c43f27639e)),
                          vcreate_f32(UINT64_C(0x3f4f40133ef22d40)));
      clear_neon_saturated();
      //  Expect: "result" = 3f8e00003fba00003fbc80003f9e0000
      result = vrsqrteq_f32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 0);
         exp = ((float32_t) 1.234375);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 1);
         exp = ((float32_t) 1.47265625);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 2);
         exp = ((float32_t) 1.453125);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 2 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 3);
         exp = ((float32_t) 1.109375);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 3 ", exp, got);
            }
      }
   }
}
}
void dotests_2709() {

{
   {
      uint32x4_t arg1;
      uint32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"rsqrte\", fnname = \"vrsqrteq_u32\", rettype = \"uint32x4_t\", argtypes = \"[uint32x4_t]\", vals = [VectorVal [IntegerVal 4294967295,IntegerVal 2147516415,IntegerVal 2147483647,IntegerVal 32767]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u32(vcreate_u32(UINT64_C(0x80007fffffffffff)),
                          vcreate_u32(UINT64_C(0x00007fff7fffffff)));
      clear_neon_saturated();
      //  Expect: "result" = ffffffffb5000000b480000080000000
      result = vrsqrteq_u32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 0);
         exp = UINT64_C(0xb480000080000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 1);
         exp = UINT64_C(0xffffffffb5000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2710() {

{
   {
      float64x1_t arg1;
      float64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"rsqrte\", fnname = \"vrsqrte_f64\", rettype = \"float64x1_t\", argtypes = \"[float64x1_t]\", vals = [VectorVal [FloatVal 0.17092719426137348]], start_saturated = False}";
      int reported = 0;
      float64_t got;
      float64_t exp;
      arg1 = vcreate_f64(UINT64_C(0x3fc5e0f13aacc0f0));
      clear_neon_saturated();
      //  Expect: "result" = 4003500000000000
      result = vrsqrte_f64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_f64(result, 0);
      exp = 2.4140625;
      if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
         }
   }
}
}
void dotests_2711() {

{
   {
      float64x2_t arg1;
      float64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"rsqrte\", fnname = \"vrsqrteq_f64\", rettype = \"float64x2_t\", argtypes = \"[float64x2_t]\", vals = [VectorVal [FloatVal 0.7806982814582141,FloatVal 0.7430656660646467]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_f64(vcreate_f64(UINT64_C(0x3fe8fb7af65d017f)),
                          vcreate_f64(UINT64_C(0x3fe7c731a5d0e651)));
      clear_neon_saturated();
      //  Expect: "result" = 3ff29000000000003ff2200000000000
      result = vrsqrteq_f64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float64_t got;
         float64_t exp;
         got = vgetq_lane_f64(result, 0);
         exp = 1.1328125;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float64_t got;
         float64_t exp;
         got = vgetq_lane_f64(result, 1);
         exp = 1.16015625;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
   }
}
}
void dotests_2712() {

{
   {
      float32_t arg1;
      float32_t result;
      char* str1 = "ReproInfo2 {semantics = \"rsqrte\", fnname = \"vrsqrtes_f32\", rettype = \"float32_t\", argtypes = \"[float32_t]\", vals = [FloatVal 0.4886056184768677], start_saturated = False}";
      int reported = 0;
      float32_t got;
      float32_t exp;
      arg1 = ((float32_t) 0.4886056184768677);
      clear_neon_saturated();
      //  Expect: "result" = 3fb70000
      result = vrsqrtes_f32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = ((float32_t) 1.4296875);
      if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %f Got: %f\n", "   ", exp, got);
         }
   }
}
}
void dotests_2713() {

{
   {
      float64_t arg1;
      float64_t result;
      char* str1 = "ReproInfo2 {semantics = \"rsqrte\", fnname = \"vrsqrted_f64\", rettype = \"float64_t\", argtypes = \"[float64_t]\", vals = [FloatVal 0.4160805269469663], start_saturated = False}";
      int reported = 0;
      float64_t got;
      float64_t exp;
      arg1 = 0.4160805269469663;
      clear_neon_saturated();
      //  Expect: "result" = 3ff8c00000000000
      result = vrsqrted_f64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = 1.546875;
      if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %f Got: %f\n", "   ", exp, got);
         }
   }
}
}
void dotests_2714() {

{
   {
      int8x8_t arg1;
      int16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpret_s16_s8\", rettype = \"int16x4_t\", argtypes = \"[int8x8_t]\", vals = [VectorVal [IntegerVal 0,IntegerVal (-124),IntegerVal (-1),IntegerVal 0,IntegerVal 127,IntegerVal (-1),IntegerVal 0,IntegerVal (-128)]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s8(UINT64_C(0x8000ff7f00ff8400));
      clear_neon_saturated();
      //  Expect: "result" = 8000ff7f00ff8400
      result = vreinterpret_s16_s8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s16(result), 0);
      exp = UINT64_C(0x8000ff7f00ff8400);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2715() {

{
   {
      int8x8_t arg1;
      int32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpret_s32_s8\", rettype = \"int32x2_t\", argtypes = \"[int8x8_t]\", vals = [VectorVal [IntegerVal (-1),IntegerVal (-128),IntegerVal (-128),IntegerVal (-41),IntegerVal (-128),IntegerVal (-128),IntegerVal (-36),IntegerVal (-1)]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s8(UINT64_C(0xffdc8080d78080ff));
      clear_neon_saturated();
      //  Expect: "result" = ffdc8080d78080ff
      result = vreinterpret_s32_s8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s32(result), 0);
      exp = UINT64_C(0xffdc8080d78080ff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2716() {

{
   {
      int8x8_t arg1;
      float32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpret_f32_s8\", rettype = \"float32x2_t\", argtypes = \"[int8x8_t]\", vals = [VectorVal [IntegerVal (-76),IntegerVal (-125),IntegerVal (-52),IntegerVal 62,IntegerVal (-96),IntegerVal (-61),IntegerVal (-52),IntegerVal 60]], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_s8(UINT64_C(0x3cccc3a03ecc83b4));
      clear_neon_saturated();
      //  Expect: "result" = 3cccc3a03ecc83b4
      result = vreinterpret_f32_s8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result, 0);
         exp = ((float32_t) 0.39944231510162354);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result, 1);
         exp = ((float32_t) 2.4995625019073486e-2);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
   }
}
}
void dotests_2717() {

{
   {
      int8x8_t arg1;
      uint8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpret_u8_s8\", rettype = \"uint8x8_t\", argtypes = \"[int8x8_t]\", vals = [VectorVal [IntegerVal 36,IntegerVal (-103),IntegerVal (-128),IntegerVal 0,IntegerVal 84,IntegerVal (-1),IntegerVal (-128),IntegerVal 0]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s8(UINT64_C(0x0080ff5400809924));
      clear_neon_saturated();
      //  Expect: "result" = 0080ff5400809924
      result = vreinterpret_u8_s8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u8(result), 0);
      exp = UINT64_C(0x0080ff5400809924);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2718() {

{
   {
      int8x8_t arg1;
      uint16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpret_u16_s8\", rettype = \"uint16x4_t\", argtypes = \"[int8x8_t]\", vals = [VectorVal [IntegerVal (-128),IntegerVal (-128),IntegerVal 0,IntegerVal (-1),IntegerVal 53,IntegerVal (-128),IntegerVal 0,IntegerVal (-43)]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s8(UINT64_C(0xd5008035ff008080));
      clear_neon_saturated();
      //  Expect: "result" = d5008035ff008080
      result = vreinterpret_u16_s8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u16(result), 0);
      exp = UINT64_C(0xd5008035ff008080);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2719() {

{
   {
      int8x8_t arg1;
      uint32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpret_u32_s8\", rettype = \"uint32x2_t\", argtypes = \"[int8x8_t]\", vals = [VectorVal [IntegerVal (-128),IntegerVal (-1),IntegerVal 0,IntegerVal 127,IntegerVal (-128),IntegerVal 127,IntegerVal 127,IntegerVal 0]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s8(UINT64_C(0x007f7f807f00ff80));
      clear_neon_saturated();
      //  Expect: "result" = 007f7f807f00ff80
      result = vreinterpret_u32_s8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u32(result), 0);
      exp = UINT64_C(0x007f7f807f00ff80);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2720() {

{
   {
      int8x8_t arg1;
      poly8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpret_p8_s8\", rettype = \"poly8x8_t\", argtypes = \"[int8x8_t]\", vals = [VectorVal [IntegerVal 127,IntegerVal (-128),IntegerVal 0,IntegerVal 127,IntegerVal (-1),IntegerVal (-1),IntegerVal (-1),IntegerVal 127]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s8(UINT64_C(0x7fffffff7f00807f));
      clear_neon_saturated();
      //  Expect: "result" = 7fffffff7f00807f
      result = vreinterpret_p8_s8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_p8(result), 0);
      exp = UINT64_C(0x7fffffff7f00807f);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2721() {

{
   {
      int8x8_t arg1;
      poly16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpret_p16_s8\", rettype = \"poly16x4_t\", argtypes = \"[int8x8_t]\", vals = [VectorVal [IntegerVal 0,IntegerVal 127,IntegerVal (-1),IntegerVal 127,IntegerVal (-1),IntegerVal 124,IntegerVal 83,IntegerVal (-128)]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s8(UINT64_C(0x80537cff7fff7f00));
      clear_neon_saturated();
      //  Expect: "result" = 80537cff7fff7f00
      result = vreinterpret_p16_s8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_p16(result), 0);
      exp = UINT64_C(0x80537cff7fff7f00);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2722() {

{
   {
      int8x8_t arg1;
      uint64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpret_u64_s8\", rettype = \"uint64x1_t\", argtypes = \"[int8x8_t]\", vals = [VectorVal [IntegerVal (-1),IntegerVal (-128),IntegerVal 0,IntegerVal 127,IntegerVal 79,IntegerVal 127,IntegerVal 69,IntegerVal 29]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s8(UINT64_C(0x1d457f4f7f0080ff));
      clear_neon_saturated();
      //  Expect: "result" = 1d457f4f7f0080ff
      result = vreinterpret_u64_s8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(result, 0);
      exp = UINT64_C(0x1d457f4f7f0080ff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2723() {

{
   {
      int8x8_t arg1;
      int64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpret_s64_s8\", rettype = \"int64x1_t\", argtypes = \"[int8x8_t]\", vals = [VectorVal [IntegerVal (-23),IntegerVal 55,IntegerVal (-1),IntegerVal 127,IntegerVal (-128),IntegerVal 85,IntegerVal 127,IntegerVal (-128)]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s8(UINT64_C(0x807f55807fff37e9));
      clear_neon_saturated();
      //  Expect: "result" = 807f55807fff37e9
      result = vreinterpret_s64_s8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s64(result), 0);
      exp = UINT64_C(0x807f55807fff37e9);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2724() {
#if __ARM_NEON_FP16_INTRINSICS

{
   {
      int8x8_t arg1;
      float16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpret_f16_s8\", rettype = \"float16x4_t\", argtypes = \"[int8x8_t]\", vals = [VectorVal [IntegerVal (-24),IntegerVal (-10),IntegerVal (-59),IntegerVal 61,IntegerVal (-26),IntegerVal (-19),IntegerVal (-77),IntegerVal 62]], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_s8(UINT64_C(0x3eb3ede63dc5f6e8));
      clear_neon_saturated();
      //  Expect: "result" = 3eb3ede63dc5f6e8
      result = vreinterpret_f16_s8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         __fp16 got;
         __fp16 exp;
         got = vget_lane_f16(result, 0);
         exp = -28288.0;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vget_lane_f16(result, 1);
         exp = 1.4423828125;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vget_lane_f16(result, 2);
         exp = -6040.0;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 2 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vget_lane_f16(result, 3);
         exp = 1.6748046875;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 3 ", exp, got);
            }
      }
   }
}
#endif
}
void dotests_2725() {

{
   {
      int16x4_t arg1;
      int8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpret_s8_s16\", rettype = \"int8x8_t\", argtypes = \"[int16x4_t]\", vals = [VectorVal [IntegerVal (-1),IntegerVal (-16981),IntegerVal (-32768),IntegerVal 0]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s16(UINT64_C(0x00008000bdabffff));
      clear_neon_saturated();
      //  Expect: "result" = 00008000bdabffff
      result = vreinterpret_s8_s16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s8(result), 0);
      exp = UINT64_C(0x00008000bdabffff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2726() {

{
   {
      int16x4_t arg1;
      int32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpret_s32_s16\", rettype = \"int32x2_t\", argtypes = \"[int16x4_t]\", vals = [VectorVal [IntegerVal 32767,IntegerVal 32767,IntegerVal (-32768),IntegerVal (-5629)]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s16(UINT64_C(0xea0380007fff7fff));
      clear_neon_saturated();
      //  Expect: "result" = ea0380007fff7fff
      result = vreinterpret_s32_s16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s32(result), 0);
      exp = UINT64_C(0xea0380007fff7fff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2727() {

{
   {
      int16x4_t arg1;
      float32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpret_f32_s16\", rettype = \"float32x2_t\", argtypes = \"[int16x4_t]\", vals = [VectorVal [IntegerVal (-21268),IntegerVal 16134,IntegerVal 15465,IntegerVal 16147]], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_s16(UINT64_C(0x3f133c693f06acec));
      clear_neon_saturated();
      //  Expect: "result" = 3f133c693f06acec
      result = vreinterpret_f32_s16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result, 0);
         exp = ((float32_t) 0.526076078414917);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result, 1);
         exp = ((float32_t) 0.5751405358314514);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
   }
}
}
void dotests_2728() {

{
   {
      int16x4_t arg1;
      uint8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpret_u8_s16\", rettype = \"uint8x8_t\", argtypes = \"[int16x4_t]\", vals = [VectorVal [IntegerVal (-24355),IntegerVal (-32768),IntegerVal (-5325),IntegerVal (-32768)]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s16(UINT64_C(0x8000eb338000a0dd));
      clear_neon_saturated();
      //  Expect: "result" = 8000eb338000a0dd
      result = vreinterpret_u8_s16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u8(result), 0);
      exp = UINT64_C(0x8000eb338000a0dd);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2729() {

{
   {
      int16x4_t arg1;
      uint16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpret_u16_s16\", rettype = \"uint16x4_t\", argtypes = \"[int16x4_t]\", vals = [VectorVal [IntegerVal 0,IntegerVal 32767,IntegerVal 32767,IntegerVal 0]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s16(UINT64_C(0x00007fff7fff0000));
      clear_neon_saturated();
      //  Expect: "result" = 00007fff7fff0000
      result = vreinterpret_u16_s16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u16(result), 0);
      exp = UINT64_C(0x00007fff7fff0000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2730() {

{
   {
      int16x4_t arg1;
      uint32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpret_u32_s16\", rettype = \"uint32x2_t\", argtypes = \"[int16x4_t]\", vals = [VectorVal [IntegerVal 11187,IntegerVal (-32768),IntegerVal 32767,IntegerVal (-1)]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s16(UINT64_C(0xffff7fff80002bb3));
      clear_neon_saturated();
      //  Expect: "result" = ffff7fff80002bb3
      result = vreinterpret_u32_s16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u32(result), 0);
      exp = UINT64_C(0xffff7fff80002bb3);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2731() {

{
   {
      int16x4_t arg1;
      poly8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpret_p8_s16\", rettype = \"poly8x8_t\", argtypes = \"[int16x4_t]\", vals = [VectorVal [IntegerVal (-32768),IntegerVal 15870,IntegerVal 0,IntegerVal (-32768)]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s16(UINT64_C(0x800000003dfe8000));
      clear_neon_saturated();
      //  Expect: "result" = 800000003dfe8000
      result = vreinterpret_p8_s16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_p8(result), 0);
      exp = UINT64_C(0x800000003dfe8000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2732() {

{
   {
      int16x4_t arg1;
      poly16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpret_p16_s16\", rettype = \"poly16x4_t\", argtypes = \"[int16x4_t]\", vals = [VectorVal [IntegerVal 32767,IntegerVal 0,IntegerVal (-32768),IntegerVal 0]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s16(UINT64_C(0x0000800000007fff));
      clear_neon_saturated();
      //  Expect: "result" = 0000800000007fff
      result = vreinterpret_p16_s16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_p16(result), 0);
      exp = UINT64_C(0x0000800000007fff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2733() {

{
   {
      int16x4_t arg1;
      uint64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpret_u64_s16\", rettype = \"uint64x1_t\", argtypes = \"[int16x4_t]\", vals = [VectorVal [IntegerVal (-1),IntegerVal 0,IntegerVal (-11837),IntegerVal (-1)]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s16(UINT64_C(0xffffd1c30000ffff));
      clear_neon_saturated();
      //  Expect: "result" = ffffd1c30000ffff
      result = vreinterpret_u64_s16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(result, 0);
      exp = UINT64_C(0xffffd1c30000ffff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2734() {

{
   {
      int16x4_t arg1;
      int64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpret_s64_s16\", rettype = \"int64x1_t\", argtypes = \"[int16x4_t]\", vals = [VectorVal [IntegerVal (-23668),IntegerVal 0,IntegerVal 0,IntegerVal 19525]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s16(UINT64_C(0x4c4500000000a38c));
      clear_neon_saturated();
      //  Expect: "result" = 4c4500000000a38c
      result = vreinterpret_s64_s16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s64(result), 0);
      exp = UINT64_C(0x4c4500000000a38c);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2735() {
#if __ARM_NEON_FP16_INTRINSICS

{
   {
      int16x4_t arg1;
      float16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpret_f16_s16\", rettype = \"float16x4_t\", argtypes = \"[int16x4_t]\", vals = [VectorVal [IntegerVal (-17530),IntegerVal 16236,IntegerVal 10641,IntegerVal 16130]], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_s16(UINT64_C(0x3f0229913f6cbb86));
      clear_neon_saturated();
      //  Expect: "result" = 3f0229913f6cbb86
      result = vreinterpret_f16_s16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         __fp16 got;
         __fp16 exp;
         got = vget_lane_f16(result, 0);
         exp = -0.9404296875;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vget_lane_f16(result, 1);
         exp = 1.85546875;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vget_lane_f16(result, 2);
         exp = 4.3487548828125e-2;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 2 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vget_lane_f16(result, 3);
         exp = 1.751953125;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 3 ", exp, got);
            }
      }
   }
}
#endif
}
void dotests_2736() {

{
   {
      int32x2_t arg1;
      int8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpret_s8_s32\", rettype = \"int8x8_t\", argtypes = \"[int32x2_t]\", vals = [VectorVal [IntegerVal 2147450879,IntegerVal (-3705)]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s32(UINT64_C(0xfffff1877fff7fff));
      clear_neon_saturated();
      //  Expect: "result" = fffff1877fff7fff
      result = vreinterpret_s8_s32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s8(result), 0);
      exp = UINT64_C(0xfffff1877fff7fff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2737() {

{
   {
      int32x2_t arg1;
      int16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpret_s16_s32\", rettype = \"int16x4_t\", argtypes = \"[int32x2_t]\", vals = [VectorVal [IntegerVal (-1),IntegerVal (-2147450881)]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s32(UINT64_C(0x80007fffffffffff));
      clear_neon_saturated();
      //  Expect: "result" = 80007fffffffffff
      result = vreinterpret_s16_s32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s16(result), 0);
      exp = UINT64_C(0x80007fffffffffff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2738() {

{
   {
      int32x2_t arg1;
      float32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpret_f32_s32\", rettype = \"float32x2_t\", argtypes = \"[int32x2_t]\", vals = [VectorVal [IntegerVal 1047881804,IntegerVal 1064425296]], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_s32(UINT64_C(0x3f71d7503e75684c));
      clear_neon_saturated();
      //  Expect: "result" = 3f71d7503e75684c
      result = vreinterpret_f32_s32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result, 0);
         exp = ((float32_t) 0.23965567350387573);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result, 1);
         exp = ((float32_t) 0.9446916580200195);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
   }
}
}
void dotests_2739() {

{
   {
      int32x2_t arg1;
      uint8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpret_u8_s32\", rettype = \"uint8x8_t\", argtypes = \"[int32x2_t]\", vals = [VectorVal [IntegerVal (-32768),IntegerVal (-32768)]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s32(UINT64_C(0xffff8000ffff8000));
      clear_neon_saturated();
      //  Expect: "result" = ffff8000ffff8000
      result = vreinterpret_u8_s32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u8(result), 0);
      exp = UINT64_C(0xffff8000ffff8000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2740() {

{
   {
      int32x2_t arg1;
      uint16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpret_u16_s32\", rettype = \"uint16x4_t\", argtypes = \"[int32x2_t]\", vals = [VectorVal [IntegerVal 2147483647,IntegerVal (-2147450880)]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s32(UINT64_C(0x800080007fffffff));
      clear_neon_saturated();
      //  Expect: "result" = 800080007fffffff
      result = vreinterpret_u16_s32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u16(result), 0);
      exp = UINT64_C(0x800080007fffffff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2741() {

{
   {
      int32x2_t arg1;
      uint32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpret_u32_s32\", rettype = \"uint32x2_t\", argtypes = \"[int32x2_t]\", vals = [VectorVal [IntegerVal 65535,IntegerVal (-2147450881)]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s32(UINT64_C(0x80007fff0000ffff));
      clear_neon_saturated();
      //  Expect: "result" = 80007fff0000ffff
      result = vreinterpret_u32_s32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u32(result), 0);
      exp = UINT64_C(0x80007fff0000ffff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2742() {

{
   {
      int32x2_t arg1;
      poly8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpret_p8_s32\", rettype = \"poly8x8_t\", argtypes = \"[int32x2_t]\", vals = [VectorVal [IntegerVal 5917,IntegerVal 1025571437]], start_saturated = True}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s32(UINT64_C(0x3d20fa6d0000171d));
      set_neon_saturated();
      //  Expect: "result" = 3d20fa6d0000171d
      result = vreinterpret_p8_s32(arg1);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_p8(result), 0);
      exp = UINT64_C(0x3d20fa6d0000171d);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2743() {

{
   {
      int32x2_t arg1;
      poly16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpret_p16_s32\", rettype = \"poly16x4_t\", argtypes = \"[int32x2_t]\", vals = [VectorVal [IntegerVal (-2147450880),IntegerVal (-1)]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s32(UINT64_C(0xffffffff80008000));
      clear_neon_saturated();
      //  Expect: "result" = ffffffff80008000
      result = vreinterpret_p16_s32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_p16(result), 0);
      exp = UINT64_C(0xffffffff80008000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2744() {

{
   {
      int32x2_t arg1;
      uint64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpret_u64_s32\", rettype = \"uint64x1_t\", argtypes = \"[int32x2_t]\", vals = [VectorVal [IntegerVal (-2147450880),IntegerVal (-2147418113)]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s32(UINT64_C(0x8000ffff80008000));
      clear_neon_saturated();
      //  Expect: "result" = 8000ffff80008000
      result = vreinterpret_u64_s32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(result, 0);
      exp = UINT64_C(0x8000ffff80008000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2745() {

{
   {
      int32x2_t arg1;
      int64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpret_s64_s32\", rettype = \"int64x1_t\", argtypes = \"[int32x2_t]\", vals = [VectorVal [IntegerVal 1179647,IntegerVal 1854668800]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s32(UINT64_C(0x6e8c00000011ffff));
      clear_neon_saturated();
      //  Expect: "result" = 6e8c00000011ffff
      result = vreinterpret_s64_s32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s64(result), 0);
      exp = UINT64_C(0x6e8c00000011ffff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2746() {
#if __ARM_NEON_FP16_INTRINSICS

{
   {
      int32x2_t arg1;
      float16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpret_f16_s32\", rettype = \"float16x4_t\", argtypes = \"[int32x2_t]\", vals = [VectorVal [IntegerVal 1051144024,IntegerVal 1049716152]], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_s32(UINT64_C(0x3e9165b83ea72f58));
      clear_neon_saturated();
      //  Expect: "result" = 3e9165b83ea72f58
      result = vreinterpret_f16_s32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         __fp16 got;
         __fp16 exp;
         got = vget_lane_f16(result, 0);
         exp = 0.11474609375;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vget_lane_f16(result, 1);
         exp = 1.6630859375;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vget_lane_f16(result, 2);
         exp = 1464.0;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 2 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vget_lane_f16(result, 3);
         exp = 1.6416015625;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 3 ", exp, got);
            }
      }
   }
}
#endif
}
void dotests_2747() {

{
   {
      float32x2_t arg1;
      int8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpret_s8_f32\", rettype = \"int8x8_t\", argtypes = \"[float32x2_t]\", vals = [VectorVal [FloatVal 0.8546260595321655,FloatVal 0.9548693895339966]], start_saturated = True}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_f32(UINT64_C(0x3f7472523f5ac8c6));
      set_neon_saturated();
      //  Expect: "result" = 3f7472523f5ac8c6
      result = vreinterpret_s8_f32(arg1);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s8(result), 0);
      exp = UINT64_C(0x3f7472523f5ac8c6);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2748() {

{
   {
      float32x2_t arg1;
      int16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpret_s16_f32\", rettype = \"int16x4_t\", argtypes = \"[float32x2_t]\", vals = [VectorVal [FloatVal 0.7759226560592651,FloatVal 0.4858841300010681]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_f32(UINT64_C(0x3ef8c5ce3f46a2de));
      clear_neon_saturated();
      //  Expect: "result" = 3ef8c5ce3f46a2de
      result = vreinterpret_s16_f32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s16(result), 0);
      exp = UINT64_C(0x3ef8c5ce3f46a2de);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2749() {

{
   {
      float32x2_t arg1;
      int32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpret_s32_f32\", rettype = \"int32x2_t\", argtypes = \"[float32x2_t]\", vals = [VectorVal [FloatVal 0.9588850140571594,FloatVal 0.8028910756111145]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_f32(UINT64_C(0x3f4d8a453f75797d));
      clear_neon_saturated();
      //  Expect: "result" = 3f4d8a453f75797d
      result = vreinterpret_s32_f32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s32(result), 0);
      exp = UINT64_C(0x3f4d8a453f75797d);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2750() {

{
   {
      float32x2_t arg1;
      uint8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpret_u8_f32\", rettype = \"uint8x8_t\", argtypes = \"[float32x2_t]\", vals = [VectorVal [FloatVal 0.185857892036438,FloatVal 0.5570162534713745]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_f32(UINT64_C(0x3f0e989e3e3e5188));
      clear_neon_saturated();
      //  Expect: "result" = 3f0e989e3e3e5188
      result = vreinterpret_u8_f32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u8(result), 0);
      exp = UINT64_C(0x3f0e989e3e3e5188);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2751() {

{
   {
      float32x2_t arg1;
      uint16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpret_u16_f32\", rettype = \"uint16x4_t\", argtypes = \"[float32x2_t]\", vals = [VectorVal [FloatVal 0.6291034817695618,FloatVal 0.8877595663070679]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_f32(UINT64_C(0x3f6344363f210ced));
      clear_neon_saturated();
      //  Expect: "result" = 3f6344363f210ced
      result = vreinterpret_u16_f32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u16(result), 0);
      exp = UINT64_C(0x3f6344363f210ced);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2752() {

{
   {
      float32x2_t arg1;
      uint32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpret_u32_f32\", rettype = \"uint32x2_t\", argtypes = \"[float32x2_t]\", vals = [VectorVal [FloatVal 0.6794434785842896,FloatVal 0.7797624468803406]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_f32(UINT64_C(0x3f479e833f2df002));
      clear_neon_saturated();
      //  Expect: "result" = 3f479e833f2df002
      result = vreinterpret_u32_f32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u32(result), 0);
      exp = UINT64_C(0x3f479e833f2df002);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2753() {

{
   {
      float32x2_t arg1;
      poly8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpret_p8_f32\", rettype = \"poly8x8_t\", argtypes = \"[float32x2_t]\", vals = [VectorVal [FloatVal 0.9447101354598999,FloatVal 0.6355336308479309]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_f32(UINT64_C(0x3f22b2553f71d886));
      clear_neon_saturated();
      //  Expect: "result" = 3f22b2553f71d886
      result = vreinterpret_p8_f32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_p8(result), 0);
      exp = UINT64_C(0x3f22b2553f71d886);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2754() {

{
   {
      float32x2_t arg1;
      poly16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpret_p16_f32\", rettype = \"poly16x4_t\", argtypes = \"[float32x2_t]\", vals = [VectorVal [FloatVal 0.6255528926849365,FloatVal 0.6240644454956055]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_f32(UINT64_C(0x3f1fc2b03f20243c));
      clear_neon_saturated();
      //  Expect: "result" = 3f1fc2b03f20243c
      result = vreinterpret_p16_f32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_p16(result), 0);
      exp = UINT64_C(0x3f1fc2b03f20243c);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2755() {

{
   {
      float32x2_t arg1;
      uint64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpret_u64_f32\", rettype = \"uint64x1_t\", argtypes = \"[float32x2_t]\", vals = [VectorVal [FloatVal 0.8906951546669006,FloatVal 0.2771250605583191]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_f32(UINT64_C(0x3e8de3563f640499));
      clear_neon_saturated();
      //  Expect: "result" = 3e8de3563f640499
      result = vreinterpret_u64_f32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(result, 0);
      exp = UINT64_C(0x3e8de3563f640499);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2756() {

{
   {
      float32x2_t arg1;
      int64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpret_s64_f32\", rettype = \"int64x1_t\", argtypes = \"[float32x2_t]\", vals = [VectorVal [FloatVal 0.2742379307746887,FloatVal 0.20994973182678223]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_f32(UINT64_C(0x3e56fd103e8c68ea));
      clear_neon_saturated();
      //  Expect: "result" = 3e56fd103e8c68ea
      result = vreinterpret_s64_f32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s64(result), 0);
      exp = UINT64_C(0x3e56fd103e8c68ea);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2757() {
#if __ARM_NEON_FP16_INTRINSICS

{
   {
      float32x2_t arg1;
      float16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpret_f16_f32\", rettype = \"float16x4_t\", argtypes = \"[float32x2_t]\", vals = [VectorVal [FloatVal 0.8069887757301331,FloatVal 0.5101466774940491]], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_f32(UINT64_C(0x3f0298f93f4e96d1));
      clear_neon_saturated();
      //  Expect: "result" = 3f0298f93f4e96d1
      result = vreinterpret_f16_f32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         __fp16 got;
         __fp16 exp;
         got = vget_lane_f16(result, 0);
         exp = -1.6641616821289063e-3;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vget_lane_f16(result, 1);
         exp = 1.826171875;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vget_lane_f16(result, 2);
         exp = -2.4280548095703125e-3;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 2 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vget_lane_f16(result, 3);
         exp = 1.751953125;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 3 ", exp, got);
            }
      }
   }
}
#endif
}
void dotests_2758() {

{
   {
      uint8x8_t arg1;
      int8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpret_s8_u8\", rettype = \"int8x8_t\", argtypes = \"[uint8x8_t]\", vals = [VectorVal [IntegerVal 198,IntegerVal 128,IntegerVal 255,IntegerVal 194,IntegerVal 128,IntegerVal 127,IntegerVal 127,IntegerVal 128]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u8(UINT64_C(0x807f7f80c2ff80c6));
      clear_neon_saturated();
      //  Expect: "result" = 807f7f80c2ff80c6
      result = vreinterpret_s8_u8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s8(result), 0);
      exp = UINT64_C(0x807f7f80c2ff80c6);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2759() {

{
   {
      uint8x8_t arg1;
      int16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpret_s16_u8\", rettype = \"int16x4_t\", argtypes = \"[uint8x8_t]\", vals = [VectorVal [IntegerVal 235,IntegerVal 255,IntegerVal 127,IntegerVal 17,IntegerVal 127,IntegerVal 0,IntegerVal 128,IntegerVal 255]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u8(UINT64_C(0xff80007f117fffeb));
      clear_neon_saturated();
      //  Expect: "result" = ff80007f117fffeb
      result = vreinterpret_s16_u8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s16(result), 0);
      exp = UINT64_C(0xff80007f117fffeb);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2760() {

{
   {
      uint8x8_t arg1;
      int32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpret_s32_u8\", rettype = \"int32x2_t\", argtypes = \"[uint8x8_t]\", vals = [VectorVal [IntegerVal 127,IntegerVal 89,IntegerVal 0,IntegerVal 0,IntegerVal 195,IntegerVal 0,IntegerVal 127,IntegerVal 255]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u8(UINT64_C(0xff7f00c30000597f));
      clear_neon_saturated();
      //  Expect: "result" = ff7f00c30000597f
      result = vreinterpret_s32_u8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s32(result), 0);
      exp = UINT64_C(0xff7f00c30000597f);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2761() {

{
   {
      uint8x8_t arg1;
      float32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpret_f32_u8\", rettype = \"float32x2_t\", argtypes = \"[uint8x8_t]\", vals = [VectorVal [IntegerVal 226,IntegerVal 218,IntegerVal 10,IntegerVal 63,IntegerVal 80,IntegerVal 112,IntegerVal 22,IntegerVal 63]], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_u8(UINT64_C(0x3f1670503f0adae2));
      clear_neon_saturated();
      //  Expect: "result" = 3f1670503f0adae2
      result = vreinterpret_f32_u8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result, 0);
         exp = ((float32_t) 0.5424023866653442);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result, 1);
         exp = ((float32_t) 0.587651252746582);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
   }
}
}
void dotests_2762() {

{
   {
      uint8x8_t arg1;
      uint16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpret_u16_u8\", rettype = \"uint16x4_t\", argtypes = \"[uint8x8_t]\", vals = [VectorVal [IntegerVal 128,IntegerVal 127,IntegerVal 255,IntegerVal 127,IntegerVal 128,IntegerVal 0,IntegerVal 255,IntegerVal 255]], start_saturated = True}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u8(UINT64_C(0xffff00807fff7f80));
      set_neon_saturated();
      //  Expect: "result" = ffff00807fff7f80
      result = vreinterpret_u16_u8(arg1);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u16(result), 0);
      exp = UINT64_C(0xffff00807fff7f80);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2763() {

{
   {
      uint8x8_t arg1;
      uint32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpret_u32_u8\", rettype = \"uint32x2_t\", argtypes = \"[uint8x8_t]\", vals = [VectorVal [IntegerVal 127,IntegerVal 255,IntegerVal 255,IntegerVal 139,IntegerVal 14,IntegerVal 121,IntegerVal 255,IntegerVal 128]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u8(UINT64_C(0x80ff790e8bffff7f));
      clear_neon_saturated();
      //  Expect: "result" = 80ff790e8bffff7f
      result = vreinterpret_u32_u8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u32(result), 0);
      exp = UINT64_C(0x80ff790e8bffff7f);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2764() {

{
   {
      uint8x8_t arg1;
      poly8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpret_p8_u8\", rettype = \"poly8x8_t\", argtypes = \"[uint8x8_t]\", vals = [VectorVal [IntegerVal 127,IntegerVal 0,IntegerVal 128,IntegerVal 128,IntegerVal 255,IntegerVal 128,IntegerVal 188,IntegerVal 0]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u8(UINT64_C(0x00bc80ff8080007f));
      clear_neon_saturated();
      //  Expect: "result" = 00bc80ff8080007f
      result = vreinterpret_p8_u8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_p8(result), 0);
      exp = UINT64_C(0x00bc80ff8080007f);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2765() {

{
   {
      uint8x8_t arg1;
      poly16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpret_p16_u8\", rettype = \"poly16x4_t\", argtypes = \"[uint8x8_t]\", vals = [VectorVal [IntegerVal 195,IntegerVal 127,IntegerVal 98,IntegerVal 255,IntegerVal 255,IntegerVal 128,IntegerVal 255,IntegerVal 255]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u8(UINT64_C(0xffff80ffff627fc3));
      clear_neon_saturated();
      //  Expect: "result" = ffff80ffff627fc3
      result = vreinterpret_p16_u8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_p16(result), 0);
      exp = UINT64_C(0xffff80ffff627fc3);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2766() {

{
   {
      uint8x8_t arg1;
      uint64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpret_u64_u8\", rettype = \"uint64x1_t\", argtypes = \"[uint8x8_t]\", vals = [VectorVal [IntegerVal 127,IntegerVal 0,IntegerVal 128,IntegerVal 0,IntegerVal 128,IntegerVal 0,IntegerVal 128,IntegerVal 255]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u8(UINT64_C(0xff8000800080007f));
      clear_neon_saturated();
      //  Expect: "result" = ff8000800080007f
      result = vreinterpret_u64_u8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(result, 0);
      exp = UINT64_C(0xff8000800080007f);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2767() {

{
   {
      uint8x8_t arg1;
      int64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpret_s64_u8\", rettype = \"int64x1_t\", argtypes = \"[uint8x8_t]\", vals = [VectorVal [IntegerVal 128,IntegerVal 255,IntegerVal 0,IntegerVal 0,IntegerVal 127,IntegerVal 127,IntegerVal 127,IntegerVal 27]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u8(UINT64_C(0x1b7f7f7f0000ff80));
      clear_neon_saturated();
      //  Expect: "result" = 1b7f7f7f0000ff80
      result = vreinterpret_s64_u8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s64(result), 0);
      exp = UINT64_C(0x1b7f7f7f0000ff80);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2768() {
#if __ARM_NEON_FP16_INTRINSICS

{
   {
      uint8x8_t arg1;
      float16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpret_f16_u8\", rettype = \"float16x4_t\", argtypes = \"[uint8x8_t]\", vals = [VectorVal [IntegerVal 224,IntegerVal 95,IntegerVal 183,IntegerVal 61,IntegerVal 98,IntegerVal 109,IntegerVal 229,IntegerVal 62]], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_u8(UINT64_C(0x3ee56d623db75fe0));
      clear_neon_saturated();
      //  Expect: "result" = 3ee56d623db75fe0
      result = vreinterpret_f16_u8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         __fp16 got;
         __fp16 exp;
         got = vget_lane_f16(result, 0);
         exp = 504.0;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vget_lane_f16(result, 1);
         exp = 1.4287109375;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vget_lane_f16(result, 2);
         exp = 5512.0;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 2 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vget_lane_f16(result, 3);
         exp = 1.7236328125;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 3 ", exp, got);
            }
      }
   }
}
#endif
}
void dotests_2769() {

{
   {
      uint16x4_t arg1;
      int8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpret_s8_u16\", rettype = \"int8x8_t\", argtypes = \"[uint16x4_t]\", vals = [VectorVal [IntegerVal 65535,IntegerVal 0,IntegerVal 32768,IntegerVal 32768]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u16(UINT64_C(0x800080000000ffff));
      clear_neon_saturated();
      //  Expect: "result" = 800080000000ffff
      result = vreinterpret_s8_u16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s8(result), 0);
      exp = UINT64_C(0x800080000000ffff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2770() {

{
   {
      uint16x4_t arg1;
      int16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpret_s16_u16\", rettype = \"int16x4_t\", argtypes = \"[uint16x4_t]\", vals = [VectorVal [IntegerVal 32767,IntegerVal 32768,IntegerVal 0,IntegerVal 65535]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u16(UINT64_C(0xffff000080007fff));
      clear_neon_saturated();
      //  Expect: "result" = ffff000080007fff
      result = vreinterpret_s16_u16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s16(result), 0);
      exp = UINT64_C(0xffff000080007fff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2771() {

{
   {
      uint16x4_t arg1;
      int32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpret_s32_u16\", rettype = \"int32x2_t\", argtypes = \"[uint16x4_t]\", vals = [VectorVal [IntegerVal 32768,IntegerVal 0,IntegerVal 0,IntegerVal 32768]], start_saturated = True}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u16(UINT64_C(0x8000000000008000));
      set_neon_saturated();
      //  Expect: "result" = 8000000000008000
      result = vreinterpret_s32_u16(arg1);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s32(result), 0);
      exp = UINT64_C(0x8000000000008000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2772() {

{
   {
      uint16x4_t arg1;
      float32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpret_f32_u16\", rettype = \"float32x2_t\", argtypes = \"[uint16x4_t]\", vals = [VectorVal [IntegerVal 40704,IntegerVal 15166,IntegerVal 44249,IntegerVal 16145]], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_u16(UINT64_C(0x3f11acd93b3e9f00));
      clear_neon_saturated();
      //  Expect: "result" = 3f11acd93b3e9f00
      result = vreinterpret_f32_u16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result, 0);
         exp = ((float32_t) 2.908647060394287e-3);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result, 1);
         exp = ((float32_t) 0.5690436959266663);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
   }
}
}
void dotests_2773() {

{
   {
      uint16x4_t arg1;
      uint8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpret_u8_u16\", rettype = \"uint8x8_t\", argtypes = \"[uint16x4_t]\", vals = [VectorVal [IntegerVal 31885,IntegerVal 32768,IntegerVal 32768,IntegerVal 65535]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u16(UINT64_C(0xffff800080007c8d));
      clear_neon_saturated();
      //  Expect: "result" = ffff800080007c8d
      result = vreinterpret_u8_u16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u8(result), 0);
      exp = UINT64_C(0xffff800080007c8d);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2774() {

{
   {
      uint16x4_t arg1;
      uint32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpret_u32_u16\", rettype = \"uint32x2_t\", argtypes = \"[uint16x4_t]\", vals = [VectorVal [IntegerVal 32768,IntegerVal 32767,IntegerVal 0,IntegerVal 0]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u16(UINT64_C(0x000000007fff8000));
      clear_neon_saturated();
      //  Expect: "result" = 000000007fff8000
      result = vreinterpret_u32_u16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u32(result), 0);
      exp = UINT64_C(0x000000007fff8000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2775() {

{
   {
      uint16x4_t arg1;
      poly8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpret_p8_u16\", rettype = \"poly8x8_t\", argtypes = \"[uint16x4_t]\", vals = [VectorVal [IntegerVal 32768,IntegerVal 0,IntegerVal 0,IntegerVal 44167]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u16(UINT64_C(0xac87000000008000));
      clear_neon_saturated();
      //  Expect: "result" = ac87000000008000
      result = vreinterpret_p8_u16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_p8(result), 0);
      exp = UINT64_C(0xac87000000008000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2776() {

{
   {
      uint16x4_t arg1;
      poly16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpret_p16_u16\", rettype = \"poly16x4_t\", argtypes = \"[uint16x4_t]\", vals = [VectorVal [IntegerVal 32768,IntegerVal 0,IntegerVal 32768,IntegerVal 0]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u16(UINT64_C(0x0000800000008000));
      clear_neon_saturated();
      //  Expect: "result" = 0000800000008000
      result = vreinterpret_p16_u16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_p16(result), 0);
      exp = UINT64_C(0x0000800000008000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2777() {

{
   {
      uint16x4_t arg1;
      uint64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpret_u64_u16\", rettype = \"uint64x1_t\", argtypes = \"[uint16x4_t]\", vals = [VectorVal [IntegerVal 33922,IntegerVal 65535,IntegerVal 0,IntegerVal 32768]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u16(UINT64_C(0x80000000ffff8482));
      clear_neon_saturated();
      //  Expect: "result" = 80000000ffff8482
      result = vreinterpret_u64_u16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(result, 0);
      exp = UINT64_C(0x80000000ffff8482);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2778() {

{
   {
      uint16x4_t arg1;
      int64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpret_s64_u16\", rettype = \"int64x1_t\", argtypes = \"[uint16x4_t]\", vals = [VectorVal [IntegerVal 0,IntegerVal 65535,IntegerVal 220,IntegerVal 46215]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u16(UINT64_C(0xb48700dcffff0000));
      clear_neon_saturated();
      //  Expect: "result" = b48700dcffff0000
      result = vreinterpret_s64_u16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s64(result), 0);
      exp = UINT64_C(0xb48700dcffff0000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2779() {
#if __ARM_NEON_FP16_INTRINSICS

{
   {
      uint16x4_t arg1;
      float16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpret_f16_u16\", rettype = \"float16x4_t\", argtypes = \"[uint16x4_t]\", vals = [VectorVal [IntegerVal 11358,IntegerVal 16095,IntegerVal 42344,IntegerVal 15769]], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_u16(UINT64_C(0x3d99a5683edf2c5e));
      clear_neon_saturated();
      //  Expect: "result" = 3d99a5683edf2c5e
      result = vreinterpret_f16_u16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         __fp16 got;
         __fp16 exp;
         got = vget_lane_f16(result, 0);
         exp = 6.82373046875e-2;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vget_lane_f16(result, 1);
         exp = 1.7177734375;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vget_lane_f16(result, 2);
         exp = -2.11181640625e-2;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 2 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vget_lane_f16(result, 3);
         exp = 1.3994140625;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 3 ", exp, got);
            }
      }
   }
}
#endif
}
void dotests_2780() {

{
   {
      uint32x2_t arg1;
      int8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpret_s8_u32\", rettype = \"int8x8_t\", argtypes = \"[uint32x2_t]\", vals = [VectorVal [IntegerVal 2147549183,IntegerVal 2614755328]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u32(UINT64_C(0x9bda00008000ffff));
      clear_neon_saturated();
      //  Expect: "result" = 9bda00008000ffff
      result = vreinterpret_s8_u32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s8(result), 0);
      exp = UINT64_C(0x9bda00008000ffff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2781() {

{
   {
      uint32x2_t arg1;
      int16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpret_s16_u32\", rettype = \"int16x4_t\", argtypes = \"[uint32x2_t]\", vals = [VectorVal [IntegerVal 4294967295,IntegerVal 4294908468]], start_saturated = True}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u32(UINT64_C(0xffff1a34ffffffff));
      set_neon_saturated();
      //  Expect: "result" = ffff1a34ffffffff
      result = vreinterpret_s16_u32(arg1);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s16(result), 0);
      exp = UINT64_C(0xffff1a34ffffffff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2782() {

{
   {
      uint32x2_t arg1;
      int32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpret_s32_u32\", rettype = \"int32x2_t\", argtypes = \"[uint32x2_t]\", vals = [VectorVal [IntegerVal 4294934528,IntegerVal 4294967295]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u32(UINT64_C(0xffffffffffff8000));
      clear_neon_saturated();
      //  Expect: "result" = ffffffffffff8000
      result = vreinterpret_s32_u32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s32(result), 0);
      exp = UINT64_C(0xffffffffffff8000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2783() {

{
   {
      uint32x2_t arg1;
      float32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpret_f32_u32\", rettype = \"float32x2_t\", argtypes = \"[uint32x2_t]\", vals = [VectorVal [IntegerVal 1064359173,IntegerVal 1036461504]], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_u32(UINT64_C(0x3dc725c03f70d505));
      clear_neon_saturated();
      //  Expect: "result" = 3dc725c03f70d505
      result = vreinterpret_f32_u32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result, 0);
         exp = ((float32_t) 0.9407504200935364);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result, 1);
         exp = ((float32_t) 9.723997116088867e-2);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
   }
}
}
void dotests_2784() {

{
   {
      uint32x2_t arg1;
      uint8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpret_u8_u32\", rettype = \"uint8x8_t\", argtypes = \"[uint32x2_t]\", vals = [VectorVal [IntegerVal 0,IntegerVal 32768]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u32(UINT64_C(0x0000800000000000));
      clear_neon_saturated();
      //  Expect: "result" = 0000800000000000
      result = vreinterpret_u8_u32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u8(result), 0);
      exp = UINT64_C(0x0000800000000000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2785() {

{
   {
      uint32x2_t arg1;
      uint16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpret_u16_u32\", rettype = \"uint16x4_t\", argtypes = \"[uint32x2_t]\", vals = [VectorVal [IntegerVal 2147450880,IntegerVal 2147450880]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u32(UINT64_C(0x7fff80007fff8000));
      clear_neon_saturated();
      //  Expect: "result" = 7fff80007fff8000
      result = vreinterpret_u16_u32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u16(result), 0);
      exp = UINT64_C(0x7fff80007fff8000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2786() {

{
   {
      uint32x2_t arg1;
      poly8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpret_p8_u32\", rettype = \"poly8x8_t\", argtypes = \"[uint32x2_t]\", vals = [VectorVal [IntegerVal 2147516415,IntegerVal 2147433615]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u32(UINT64_C(0x7fff3c8f80007fff));
      clear_neon_saturated();
      //  Expect: "result" = 7fff3c8f80007fff
      result = vreinterpret_p8_u32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_p8(result), 0);
      exp = UINT64_C(0x7fff3c8f80007fff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2787() {

{
   {
      uint32x2_t arg1;
      poly16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpret_p16_u32\", rettype = \"poly16x4_t\", argtypes = \"[uint32x2_t]\", vals = [VectorVal [IntegerVal 4294934528,IntegerVal 4294901760]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u32(UINT64_C(0xffff0000ffff8000));
      clear_neon_saturated();
      //  Expect: "result" = ffff0000ffff8000
      result = vreinterpret_p16_u32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_p16(result), 0);
      exp = UINT64_C(0xffff0000ffff8000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2788() {

{
   {
      uint32x2_t arg1;
      uint64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpret_u64_u32\", rettype = \"uint64x1_t\", argtypes = \"[uint32x2_t]\", vals = [VectorVal [IntegerVal 4294901760,IntegerVal 4294958844]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u32(UINT64_C(0xffffdefcffff0000));
      clear_neon_saturated();
      //  Expect: "result" = ffffdefcffff0000
      result = vreinterpret_u64_u32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(result, 0);
      exp = UINT64_C(0xffffdefcffff0000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2789() {

{
   {
      uint32x2_t arg1;
      int64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpret_s64_u32\", rettype = \"int64x1_t\", argtypes = \"[uint32x2_t]\", vals = [VectorVal [IntegerVal 32768,IntegerVal 2147450880]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u32(UINT64_C(0x7fff800000008000));
      clear_neon_saturated();
      //  Expect: "result" = 7fff800000008000
      result = vreinterpret_s64_u32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s64(result), 0);
      exp = UINT64_C(0x7fff800000008000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2790() {
#if __ARM_NEON_FP16_INTRINSICS

{
   {
      uint32x2_t arg1;
      float16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpret_f16_u32\", rettype = \"float16x4_t\", argtypes = \"[uint32x2_t]\", vals = [VectorVal [IntegerVal 1058402803,IntegerVal 1060221343]], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_u32(UINT64_C(0x3f31b19f3f15f1f3));
      clear_neon_saturated();
      //  Expect: "result" = 3f31b19f3f15f1f3
      result = vreinterpret_f16_u32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         __fp16 got;
         __fp16 exp;
         got = vget_lane_f16(result, 0);
         exp = -12184.0;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vget_lane_f16(result, 1);
         exp = 1.7705078125;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vget_lane_f16(result, 2);
         exp = -0.1756591796875;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 2 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vget_lane_f16(result, 3);
         exp = 1.7978515625;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 3 ", exp, got);
            }
      }
   }
}
#endif
}
void dotests_2791() {

{
   {
      poly8x8_t arg1;
      int8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpret_s8_p8\", rettype = \"int8x8_t\", argtypes = \"[poly8x8_t]\", vals = [VectorVal [PolyVal [0,0,0,0,1,0,1,1],PolyVal [0,0,1,1,1,0,1,1],PolyVal [0,0,1,1,0,1,1,1],PolyVal [0,0,1,0,0,1,0,0],PolyVal [1,0,0,1,0,1,0,0],PolyVal [1,0,1,1,0,0,0,0],PolyVal [1,1,0,0,0,1,0,0],PolyVal [1,1,1,0,0,0,0,1]]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_p8(UINT64_C(0x87230d2924ecdcd0));
      clear_neon_saturated();
      //  Expect: "result" = 87230d2924ecdcd0
      result = vreinterpret_s8_p8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s8(result), 0);
      exp = UINT64_C(0x87230d2924ecdcd0);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2792() {

{
   {
      poly8x8_t arg1;
      int16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpret_s16_p8\", rettype = \"int16x4_t\", argtypes = \"[poly8x8_t]\", vals = [VectorVal [PolyVal [0,0,0,0,1,0,1,0],PolyVal [1,0,0,1,1,0,1,0],PolyVal [1,1,0,1,0,0,1,0],PolyVal [1,1,0,1,0,0,1,1],PolyVal [0,0,1,0,1,0,0,1],PolyVal [1,1,1,1,1,0,0,0],PolyVal [1,1,0,0,1,1,1,0],PolyVal [0,0,1,0,0,1,0,1]]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_p8(UINT64_C(0xa4731f94cb4b5950));
      clear_neon_saturated();
      //  Expect: "result" = a4731f94cb4b5950
      result = vreinterpret_s16_p8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s16(result), 0);
      exp = UINT64_C(0xa4731f94cb4b5950);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2793() {

{
   {
      poly8x8_t arg1;
      int32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpret_s32_p8\", rettype = \"int32x2_t\", argtypes = \"[poly8x8_t]\", vals = [VectorVal [PolyVal [1,1,1,0,0,0,0,0],PolyVal [0,0,0,1,0,0,1,0],PolyVal [1,0,0,0,0,0,1,0],PolyVal [1,0,1,0,1,1,1,1],PolyVal [1,0,0,1,0,1,1,1],PolyVal [0,0,1,1,0,1,0,0],PolyVal [1,0,0,1,1,1,1,1],PolyVal [0,1,1,0,1,1,0,0]]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_p8(UINT64_C(0x36f92ce9f5414807));
      clear_neon_saturated();
      //  Expect: "result" = 36f92ce9f5414807
      result = vreinterpret_s32_p8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s32(result), 0);
      exp = UINT64_C(0x36f92ce9f5414807);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2794() {

{
   {
      poly8x8_t arg1;
      float32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpret_f32_p8\", rettype = \"float32x2_t\", argtypes = \"[poly8x8_t]\", vals = [VectorVal [PolyVal [0,1,0,1,1,1,0,1],PolyVal [0,1,0,0,0,1,0,0],PolyVal [0,1,1,1,1,0,1,1],PolyVal [0,1,1,1,1,1,0,0],PolyVal [1,1,1,1,0,1,1,0],PolyVal [1,0,1,0,0,0,0,0],PolyVal [1,0,1,0,0,1,0,0],PolyVal [1,1,1,1,1,1,0,0]]], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_p8(UINT64_C(0x3f25056f3ede22ba));
      clear_neon_saturated();
      //  Expect: "result" = 3f25056f3ede22ba
      result = vreinterpret_f32_p8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result, 0);
         exp = ((float32_t) 0.4338586926460266);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result, 1);
         exp = ((float32_t) 0.6446141600608826);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
   }
}
}
void dotests_2795() {

{
   {
      poly8x8_t arg1;
      uint8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpret_u8_p8\", rettype = \"uint8x8_t\", argtypes = \"[poly8x8_t]\", vals = [VectorVal [PolyVal [0,0,1,0,0,1,1,1],PolyVal [0,1,0,1,0,1,0,1],PolyVal [0,0,1,0,0,0,1,0],PolyVal [0,0,0,0,1,0,0,1],PolyVal [1,1,1,0,0,0,0,0],PolyVal [1,0,1,0,0,0,1,0],PolyVal [1,1,0,0,0,0,0,1],PolyVal [1,0,0,1,1,0,0,0]]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_p8(UINT64_C(0x198345079044aae4));
      clear_neon_saturated();
      //  Expect: "result" = 198345079044aae4
      result = vreinterpret_u8_p8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u8(result), 0);
      exp = UINT64_C(0x198345079044aae4);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2796() {

{
   {
      poly8x8_t arg1;
      uint16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpret_u16_p8\", rettype = \"uint16x4_t\", argtypes = \"[poly8x8_t]\", vals = [VectorVal [PolyVal [0,0,0,1,1,0,0,1],PolyVal [0,1,1,1,0,0,0,0],PolyVal [0,0,1,0,0,1,0,0],PolyVal [0,0,1,1,0,1,0,1],PolyVal [1,0,1,1,1,0,0,0],PolyVal [1,0,0,0,0,0,0,1],PolyVal [0,0,1,0,0,1,0,1],PolyVal [1,1,0,0,1,0,0,0]]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_p8(UINT64_C(0x13a4811dac240e98));
      clear_neon_saturated();
      //  Expect: "result" = 13a4811dac240e98
      result = vreinterpret_u16_p8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u16(result), 0);
      exp = UINT64_C(0x13a4811dac240e98);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2797() {

{
   {
      poly8x8_t arg1;
      uint32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpret_u32_p8\", rettype = \"uint32x2_t\", argtypes = \"[poly8x8_t]\", vals = [VectorVal [PolyVal [0,1,1,0,1,1,1,1],PolyVal [0,1,1,1,0,0,1,0],PolyVal [0,1,1,0,1,1,1,0],PolyVal [0,1,0,1,0,0,1,0],PolyVal [0,0,0,1,0,0,1,0],PolyVal [1,0,1,0,0,1,1,0],PolyVal [0,0,1,1,0,1,0,1],PolyVal [0,1,1,0,0,1,0,1]]], start_saturated = True}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_p8(UINT64_C(0xa6ac65484a764ef6));
      set_neon_saturated();
      //  Expect: "result" = a6ac65484a764ef6
      result = vreinterpret_u32_p8(arg1);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u32(result), 0);
      exp = UINT64_C(0xa6ac65484a764ef6);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2798() {

{
   {
      poly8x8_t arg1;
      poly16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpret_p16_p8\", rettype = \"poly16x4_t\", argtypes = \"[poly8x8_t]\", vals = [VectorVal [PolyVal [1,0,0,1,1,1,1,0],PolyVal [1,1,1,0,1,0,0,1],PolyVal [1,0,1,0,1,0,1,0],PolyVal [1,0,0,0,1,0,0,1],PolyVal [1,0,1,0,0,1,0,0],PolyVal [0,0,1,1,0,0,0,1],PolyVal [1,1,0,1,1,0,1,1],PolyVal [0,1,1,0,0,1,1,1]]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_p8(UINT64_C(0xe6db8c2591559779));
      clear_neon_saturated();
      //  Expect: "result" = e6db8c2591559779
      result = vreinterpret_p16_p8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_p16(result), 0);
      exp = UINT64_C(0xe6db8c2591559779);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2799() {

{
   {
      poly8x8_t arg1;
      uint64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpret_u64_p8\", rettype = \"uint64x1_t\", argtypes = \"[poly8x8_t]\", vals = [VectorVal [PolyVal [1,1,1,1,0,0,0,1],PolyVal [0,1,0,1,1,0,0,0],PolyVal [0,1,1,1,1,1,0,1],PolyVal [0,0,0,1,1,1,0,0],PolyVal [1,0,1,1,1,1,0,0],PolyVal [1,0,0,0,0,0,1,1],PolyVal [1,1,1,0,1,0,1,0],PolyVal [0,0,1,1,0,1,1,0]]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_p8(UINT64_C(0x6c57c13d38be1a8f));
      clear_neon_saturated();
      //  Expect: "result" = 6c57c13d38be1a8f
      result = vreinterpret_u64_p8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(result, 0);
      exp = UINT64_C(0x6c57c13d38be1a8f);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2800() {

{
   {
      poly8x8_t arg1;
      int64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpret_s64_p8\", rettype = \"int64x1_t\", argtypes = \"[poly8x8_t]\", vals = [VectorVal [PolyVal [0,1,0,1,0,0,1,0],PolyVal [1,1,0,0,1,1,1,0],PolyVal [1,1,1,1,0,1,0,0],PolyVal [0,1,0,0,0,0,0,1],PolyVal [0,1,1,1,1,0,0,1],PolyVal [0,1,0,1,1,0,0,1],PolyVal [1,0,0,1,1,1,0,1],PolyVal [0,1,1,1,0,0,1,1]]], start_saturated = True}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_p8(UINT64_C(0xceb99a9e822f734a));
      set_neon_saturated();
      //  Expect: "result" = ceb99a9e822f734a
      result = vreinterpret_s64_p8(arg1);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s64(result), 0);
      exp = UINT64_C(0xceb99a9e822f734a);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2801() {
#if __ARM_NEON_FP16_INTRINSICS

{
   {
      poly8x8_t arg1;
      float16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpret_f16_p8\", rettype = \"float16x4_t\", argtypes = \"[poly8x8_t]\", vals = [VectorVal [PolyVal [0,1,1,1,0,0,1,0],PolyVal [1,0,0,1,1,0,0,1],PolyVal [1,1,1,0,0,0,1,1],PolyVal [0,1,1,1,1,1,0,0],PolyVal [0,0,1,1,0,0,0,1],PolyVal [1,1,0,1,1,1,0,1],PolyVal [1,0,1,0,1,0,0,0],PolyVal [1,1,1,1,1,1,0,0]]], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_p8(UINT64_C(0x3f15bb8c3ec7994e));
      clear_neon_saturated();
      //  Expect: "result" = 3f15bb8c3ec7994e
      result = vreinterpret_f16_p8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         __fp16 got;
         __fp16 exp;
         got = vget_lane_f16(result, 0);
         exp = -2.590179443359375e-3;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vget_lane_f16(result, 1);
         exp = 1.6943359375;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vget_lane_f16(result, 2);
         exp = -0.943359375;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 2 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vget_lane_f16(result, 3);
         exp = 1.7705078125;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 3 ", exp, got);
            }
      }
   }
}
#endif
}
void dotests_2802() {

{
   {
      poly16x4_t arg1;
      int8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpret_s8_p16\", rettype = \"int8x8_t\", argtypes = \"[poly16x4_t]\", vals = [VectorVal [PolyVal [0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1],PolyVal [0,0,0,0,0,1,1,1,0,0,1,1,0,1,0,0],PolyVal [0,0,0,1,1,0,1,1,1,1,0,1,1,0,1,0],PolyVal [0,0,1,1,0,0,0,1,1,0,0,1,0,1,0,1]]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_p16(UINT64_C(0xa98c5bd82ce08122));
      clear_neon_saturated();
      //  Expect: "result" = a98c5bd82ce08122
      result = vreinterpret_s8_p16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s8(result), 0);
      exp = UINT64_C(0xa98c5bd82ce08122);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2803() {

{
   {
      poly16x4_t arg1;
      int16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpret_s16_p16\", rettype = \"int16x4_t\", argtypes = \"[poly16x4_t]\", vals = [VectorVal [PolyVal [0,1,1,0,1,0,1,1,1,0,1,1,0,0,0,0],PolyVal [1,0,1,0,1,1,1,1,1,0,0,1,0,0,1,0],PolyVal [1,1,0,0,0,1,0,1,1,0,0,1,1,1,0,1],PolyVal [1,1,0,1,0,1,1,1,1,0,0,0,0,1,0,1]]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_p16(UINT64_C(0xa1ebb9a349f50dd6));
      clear_neon_saturated();
      //  Expect: "result" = a1ebb9a349f50dd6
      result = vreinterpret_s16_p16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s16(result), 0);
      exp = UINT64_C(0xa1ebb9a349f50dd6);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2804() {

{
   {
      poly16x4_t arg1;
      int32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpret_s32_p16\", rettype = \"int32x2_t\", argtypes = \"[poly16x4_t]\", vals = [VectorVal [PolyVal [0,1,1,1,0,0,1,1,1,0,1,1,1,1,1,0],PolyVal [1,0,1,1,1,1,0,0,0,0,0,0,0,0,1,1],PolyVal [1,0,1,0,1,0,0,1,0,1,1,1,1,0,1,0],PolyVal [0,1,1,1,1,1,1,0,1,0,0,0,0,1,1,1]]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_p16(UINT64_C(0xe17e5e95c03d7dce));
      clear_neon_saturated();
      //  Expect: "result" = e17e5e95c03d7dce
      result = vreinterpret_s32_p16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s32(result), 0);
      exp = UINT64_C(0xe17e5e95c03d7dce);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2805() {

{
   {
      poly16x4_t arg1;
      float32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpret_f32_p16\", rettype = \"float32x2_t\", argtypes = \"[poly16x4_t]\", vals = [VectorVal [PolyVal [0,1,0,0,0,0,1,0,1,1,1,0,1,1,0,1],PolyVal [1,1,1,0,1,0,0,1,0,1,1,1,1,1,0,0],PolyVal [0,0,1,0,0,1,0,1,0,1,1,1,0,1,1,0],PolyVal [0,1,0,1,0,0,1,0,1,1,1,1,1,1,0,0]]], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_p16(UINT64_C(0x3f4a6ea43e97b742));
      clear_neon_saturated();
      //  Expect: "result" = 3f4a6ea43e97b742
      result = vreinterpret_f32_p16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result, 0);
         exp = ((float32_t) 0.29632002115249634);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result, 1);
         exp = ((float32_t) 0.7907507419586182);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
   }
}
}
void dotests_2806() {

{
   {
      poly16x4_t arg1;
      uint8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpret_u8_p16\", rettype = \"uint8x8_t\", argtypes = \"[poly16x4_t]\", vals = [VectorVal [PolyVal [0,1,0,0,0,0,1,0,1,1,1,0,0,0,0,0],PolyVal [1,0,1,1,0,1,0,0,0,1,0,0,1,1,1,0],PolyVal [1,0,1,1,1,1,0,0,1,0,0,1,1,0,0,0],PolyVal [0,1,0,1,0,0,1,0,0,0,1,1,0,1,1,1]]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_p16(UINT64_C(0xec4a193d722d0742));
      clear_neon_saturated();
      //  Expect: "result" = ec4a193d722d0742
      result = vreinterpret_u8_p16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u8(result), 0);
      exp = UINT64_C(0xec4a193d722d0742);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2807() {

{
   {
      poly16x4_t arg1;
      uint16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpret_u16_p16\", rettype = \"uint16x4_t\", argtypes = \"[poly16x4_t]\", vals = [VectorVal [PolyVal [1,1,1,0,0,1,1,0,0,1,1,1,0,0,0,0],PolyVal [0,0,1,1,1,0,0,1,1,0,0,0,1,1,1,1],PolyVal [1,1,0,1,1,1,1,1,0,0,0,1,0,1,0,1],PolyVal [0,0,0,1,1,1,1,1,0,0,1,1,1,0,1,1]]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_p16(UINT64_C(0xdcf8a8fbf19c0e67));
      clear_neon_saturated();
      //  Expect: "result" = dcf8a8fbf19c0e67
      result = vreinterpret_u16_p16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u16(result), 0);
      exp = UINT64_C(0xdcf8a8fbf19c0e67);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2808() {

{
   {
      poly16x4_t arg1;
      uint32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpret_u32_p16\", rettype = \"uint32x2_t\", argtypes = \"[poly16x4_t]\", vals = [VectorVal [PolyVal [1,1,0,1,1,1,1,1,0,0,0,0,0,1,1,1],PolyVal [1,0,1,1,0,1,0,1,1,1,1,0,0,1,1,1],PolyVal [0,1,0,1,0,1,0,0,1,0,0,1,0,1,0,1],PolyVal [0,0,1,1,1,0,0,0,0,0,1,1,0,1,1,1]]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_p16(UINT64_C(0xec1ca92ae7ade0fb));
      clear_neon_saturated();
      //  Expect: "result" = ec1ca92ae7ade0fb
      result = vreinterpret_u32_p16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u32(result), 0);
      exp = UINT64_C(0xec1ca92ae7ade0fb);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2809() {

{
   {
      poly16x4_t arg1;
      poly8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpret_p8_p16\", rettype = \"poly8x8_t\", argtypes = \"[poly16x4_t]\", vals = [VectorVal [PolyVal [1,1,1,1,0,0,0,0,0,0,0,1,1,1,1,1],PolyVal [0,0,0,0,0,0,0,1,0,1,1,1,0,0,0,0],PolyVal [1,0,1,1,1,0,0,0,0,1,1,0,1,1,1,0],PolyVal [0,1,1,1,1,0,1,0,0,0,0,0,0,1,0,1]]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_p16(UINT64_C(0xa05e761d0e80f80f));
      clear_neon_saturated();
      //  Expect: "result" = a05e761d0e80f80f
      result = vreinterpret_p8_p16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_p8(result), 0);
      exp = UINT64_C(0xa05e761d0e80f80f);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2810() {

{
   {
      poly16x4_t arg1;
      uint64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpret_u64_p16\", rettype = \"uint64x1_t\", argtypes = \"[poly16x4_t]\", vals = [VectorVal [PolyVal [1,0,1,1,0,1,1,1,0,1,1,0,0,0,1,1],PolyVal [1,0,0,1,0,0,0,1,1,0,1,1,0,1,1,1],PolyVal [1,0,0,1,0,1,1,1,0,0,0,0,1,0,1,1],PolyVal [0,1,1,1,1,0,1,0,0,1,0,0,0,1,0,0]]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_p16(UINT64_C(0x225ed0e9ed89c6ed));
      clear_neon_saturated();
      //  Expect: "result" = 225ed0e9ed89c6ed
      result = vreinterpret_u64_p16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(result, 0);
      exp = UINT64_C(0x225ed0e9ed89c6ed);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2811() {

{
   {
      poly16x4_t arg1;
      int64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpret_s64_p16\", rettype = \"int64x1_t\", argtypes = \"[poly16x4_t]\", vals = [VectorVal [PolyVal [1,1,0,0,0,0,0,0,1,0,1,1,1,0,1,0],PolyVal [0,0,0,0,0,1,1,0,0,0,1,0,1,0,0,0],PolyVal [0,1,0,1,1,1,0,1,0,0,1,1,1,0,1,0],PolyVal [0,0,0,1,0,1,0,1,1,0,0,1,1,1,1,0]]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_p16(UINT64_C(0x79a85cba14605d03));
      clear_neon_saturated();
      //  Expect: "result" = 79a85cba14605d03
      result = vreinterpret_s64_p16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s64(result), 0);
      exp = UINT64_C(0x79a85cba14605d03);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2812() {
#if __ARM_NEON_FP16_INTRINSICS

{
   {
      poly16x4_t arg1;
      float16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpret_f16_p16\", rettype = \"float16x4_t\", argtypes = \"[poly16x4_t]\", vals = [VectorVal [PolyVal [0,0,1,1,0,1,0,0,1,1,0,1,0,1,1,1],PolyVal [1,1,1,1,0,1,0,1,0,1,1,1,1,1,0,0],PolyVal [0,1,0,1,0,0,1,1,0,0,1,0,0,0,1,1],PolyVal [0,0,0,1,1,1,0,0,1,1,1,1,1,1,0,0]]], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_p16(UINT64_C(0x3f38c4ca3eafeb2c));
      clear_neon_saturated();
      //  Expect: "result" = 3f38c4ca3eafeb2c
      result = vreinterpret_f16_p16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         __fp16 got;
         __fp16 exp;
         got = vget_lane_f16(result, 0);
         exp = -3672.0;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vget_lane_f16(result, 1);
         exp = 1.6708984375;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vget_lane_f16(result, 2);
         exp = -4.7890625;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 2 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vget_lane_f16(result, 3);
         exp = 1.8046875;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 3 ", exp, got);
            }
      }
   }
}
#endif
}
void dotests_2813() {

{
   {
      uint64x1_t arg1;
      int8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpret_s8_u64\", rettype = \"int8x8_t\", argtypes = \"[uint64x1_t]\", vals = [VectorVal [IntegerVal 12199547707287953053]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u64(UINT64_C(0xa94d8000f9545e9d));
      clear_neon_saturated();
      //  Expect: "result" = a94d8000f9545e9d
      result = vreinterpret_s8_u64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s8(result), 0);
      exp = UINT64_C(0xa94d8000f9545e9d);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2814() {

{
   {
      uint64x1_t arg1;
      int16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpret_s16_u64\", rettype = \"int16x4_t\", argtypes = \"[uint64x1_t]\", vals = [VectorVal [IntegerVal 9223512774343163904]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u64(UINT64_C(0x8000800000008000));
      clear_neon_saturated();
      //  Expect: "result" = 8000800000008000
      result = vreinterpret_s16_u64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s16(result), 0);
      exp = UINT64_C(0x8000800000008000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2815() {

{
   {
      uint64x1_t arg1;
      int32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpret_s32_u64\", rettype = \"int32x2_t\", argtypes = \"[uint64x1_t]\", vals = [VectorVal [IntegerVal 18446603336221163520]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u64(UINT64_C(0xffff7fffffff8000));
      clear_neon_saturated();
      //  Expect: "result" = ffff7fffffff8000
      result = vreinterpret_s32_u64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s32(result), 0);
      exp = UINT64_C(0xffff7fffffff8000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2816() {

{
   {
      uint64x1_t arg1;
      float32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpret_f32_u64\", rettype = \"float32x2_t\", argtypes = \"[uint64x1_t]\", vals = [VectorVal [IntegerVal 4546539195327778614]], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_u64(UINT64_C(0x3f188d4f3ee70f36));
      clear_neon_saturated();
      //  Expect: "result" = 3f188d4f3ee70f36
      result = vreinterpret_f32_u64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result, 0);
         exp = ((float32_t) 0.4512879252433777);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result, 1);
         exp = ((float32_t) 0.5959061980247498);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
   }
}
}
void dotests_2817() {

{
   {
      uint64x1_t arg1;
      uint8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpret_u8_u64\", rettype = \"uint8x8_t\", argtypes = \"[uint64x1_t]\", vals = [VectorVal [IntegerVal 18446672390705315840]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u64(UINT64_C(0xffffbecdffff0000));
      clear_neon_saturated();
      //  Expect: "result" = ffffbecdffff0000
      result = vreinterpret_u8_u64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u8(result), 0);
      exp = UINT64_C(0xffffbecdffff0000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2818() {

{
   {
      uint64x1_t arg1;
      uint16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpret_u16_u64\", rettype = \"uint16x4_t\", argtypes = \"[uint64x1_t]\", vals = [VectorVal [IntegerVal 9223372041149743103]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u64(UINT64_C(0x80000000ffffffff));
      clear_neon_saturated();
      //  Expect: "result" = 80000000ffffffff
      result = vreinterpret_u16_u64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u16(result), 0);
      exp = UINT64_C(0x80000000ffffffff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2819() {

{
   {
      uint64x1_t arg1;
      uint32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpret_u32_u64\", rettype = \"uint32x2_t\", argtypes = \"[uint64x1_t]\", vals = [VectorVal [IntegerVal 9223231297218936832]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u64(UINT64_C(0x7fff7fff80000000));
      clear_neon_saturated();
      //  Expect: "result" = 7fff7fff80000000
      result = vreinterpret_u32_u64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u32(result), 0);
      exp = UINT64_C(0x7fff7fff80000000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2820() {

{
   {
      uint64x1_t arg1;
      poly8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpret_p8_u64\", rettype = \"poly8x8_t\", argtypes = \"[uint64x1_t]\", vals = [VectorVal [IntegerVal 16418443120326213631]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u64(UINT64_C(0xe3da07077fffffff));
      clear_neon_saturated();
      //  Expect: "result" = e3da07077fffffff
      result = vreinterpret_p8_u64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_p8(result), 0);
      exp = UINT64_C(0xe3da07077fffffff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2821() {

{
   {
      uint64x1_t arg1;
      poly16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpret_p16_u64\", rettype = \"poly16x4_t\", argtypes = \"[uint64x1_t]\", vals = [VectorVal [IntegerVal 281470681776128]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u64(UINT64_C(0x0000ffff00008000));
      clear_neon_saturated();
      //  Expect: "result" = 0000ffff00008000
      result = vreinterpret_p16_u64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_p16(result), 0);
      exp = UINT64_C(0x0000ffff00008000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2822() {

{
   {
      uint64x1_t arg1;
      int64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpret_s64_u64\", rettype = \"int64x1_t\", argtypes = \"[uint64x1_t]\", vals = [VectorVal [IntegerVal 18446462598732840960]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u64(UINT64_C(0xffff000000000000));
      clear_neon_saturated();
      //  Expect: "result" = ffff000000000000
      result = vreinterpret_s64_u64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s64(result), 0);
      exp = UINT64_C(0xffff000000000000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2823() {
#if __ARM_NEON_FP16_INTRINSICS

{
   {
      uint64x1_t arg1;
      float16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpret_f16_u64\", rettype = \"float16x4_t\", argtypes = \"[uint64x1_t]\", vals = [VectorVal [IntegerVal 4563221703012827407]], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_u64(UINT64_C(0x3f53d1f63f6ec10f));
      clear_neon_saturated();
      //  Expect: "result" = 3f53d1f63f6ec10f
      result = vreinterpret_f16_u64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         __fp16 got;
         __fp16 exp;
         got = vget_lane_f16(result, 0);
         exp = -2.529296875;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vget_lane_f16(result, 1);
         exp = 1.857421875;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vget_lane_f16(result, 2);
         exp = -47.6875;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 2 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vget_lane_f16(result, 3);
         exp = 1.8310546875;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 3 ", exp, got);
            }
      }
   }
}
#endif
}
void dotests_2824() {

{
   {
      int64x1_t arg1;
      int8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpret_s8_s64\", rettype = \"int8x8_t\", argtypes = \"[int64x1_t]\", vals = [VectorVal [IntegerVal (-281474976697527)]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s64(UINT64_C(0xffff000000003349));
      clear_neon_saturated();
      //  Expect: "result" = ffff000000003349
      result = vreinterpret_s8_s64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s8(result), 0);
      exp = UINT64_C(0xffff000000003349);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2825() {

{
   {
      int64x1_t arg1;
      int16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpret_s16_s64\", rettype = \"int16x4_t\", argtypes = \"[int64x1_t]\", vals = [VectorVal [IntegerVal (-140735340806145)]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s64(UINT64_C(0xffff80008000ffff));
      clear_neon_saturated();
      //  Expect: "result" = ffff80008000ffff
      result = vreinterpret_s16_s64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s16(result), 0);
      exp = UINT64_C(0xffff80008000ffff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2826() {

{
   {
      int64x1_t arg1;
      int32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpret_s32_s64\", rettype = \"int32x2_t\", argtypes = \"[int64x1_t]\", vals = [VectorVal [IntegerVal 9223311353261883391]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s64(UINT64_C(0x7fffc8cf00007fff));
      clear_neon_saturated();
      //  Expect: "result" = 7fffc8cf00007fff
      result = vreinterpret_s32_s64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s32(result), 0);
      exp = UINT64_C(0x7fffc8cf00007fff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2827() {

{
   {
      int64x1_t arg1;
      float32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpret_f32_s64\", rettype = \"float32x2_t\", argtypes = \"[int64x1_t]\", vals = [VectorVal [IntegerVal 4555510604621618358]], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_s64(UINT64_C(0x3f386cc23eff1cb6));
      clear_neon_saturated();
      //  Expect: "result" = 3f386cc23eff1cb6
      result = vreinterpret_f32_s64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result, 0);
         exp = ((float32_t) 0.49826592206954956);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result, 1);
         exp = ((float32_t) 0.7204095125198364);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
   }
}
}
void dotests_2828() {

{
   {
      int64x1_t arg1;
      uint8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpret_u8_s64\", rettype = \"uint8x8_t\", argtypes = \"[int64x1_t]\", vals = [VectorVal [IntegerVal (-281472829194240)]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s64(UINT64_C(0xffff000080008000));
      clear_neon_saturated();
      //  Expect: "result" = ffff000080008000
      result = vreinterpret_u8_s64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u8(result), 0);
      exp = UINT64_C(0xffff000080008000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2829() {

{
   {
      int64x1_t arg1;
      uint16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpret_u16_s64\", rettype = \"uint16x4_t\", argtypes = \"[int64x1_t]\", vals = [VectorVal [IntegerVal (-16746077454337)]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s64(UINT64_C(0xfffff0c500007fff));
      clear_neon_saturated();
      //  Expect: "result" = fffff0c500007fff
      result = vreinterpret_u16_s64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u16(result), 0);
      exp = UINT64_C(0xfffff0c500007fff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2830() {

{
   {
      int64x1_t arg1;
      uint32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpret_u32_s64\", rettype = \"uint32x2_t\", argtypes = \"[int64x1_t]\", vals = [VectorVal [IntegerVal (-9223245176405786624)]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s64(UINT64_C(0x80007360ffff8000));
      clear_neon_saturated();
      //  Expect: "result" = 80007360ffff8000
      result = vreinterpret_u32_s64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u32(result), 0);
      exp = UINT64_C(0x80007360ffff8000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2831() {

{
   {
      int64x1_t arg1;
      poly8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpret_p8_s64\", rettype = \"poly8x8_t\", argtypes = \"[int64x1_t]\", vals = [VectorVal [IntegerVal (-281470681776129)]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s64(UINT64_C(0xffff0000ffff7fff));
      clear_neon_saturated();
      //  Expect: "result" = ffff0000ffff7fff
      result = vreinterpret_p8_s64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_p8(result), 0);
      exp = UINT64_C(0xffff0000ffff7fff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2832() {

{
   {
      int64x1_t arg1;
      poly16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpret_p16_s64\", rettype = \"poly16x4_t\", argtypes = \"[int64x1_t]\", vals = [VectorVal [IntegerVal (-9223171859166527488)]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s64(UINT64_C(0x8000b60f80000000));
      clear_neon_saturated();
      //  Expect: "result" = 8000b60f80000000
      result = vreinterpret_p16_s64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_p16(result), 0);
      exp = UINT64_C(0x8000b60f80000000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2833() {

{
   {
      int64x1_t arg1;
      uint64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpret_u64_s64\", rettype = \"uint64x1_t\", argtypes = \"[int64x1_t]\", vals = [VectorVal [IntegerVal (-140737955594241)]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s64(UINT64_C(0xffff7fffe4267fff));
      clear_neon_saturated();
      //  Expect: "result" = ffff7fffe4267fff
      result = vreinterpret_u64_s64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(result, 0);
      exp = UINT64_C(0xffff7fffe4267fff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2834() {
#if __ARM_NEON_FP16_INTRINSICS

{
   {
      int64x1_t arg1;
      float16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpret_f16_s64\", rettype = \"float16x4_t\", argtypes = \"[int64x1_t]\", vals = [VectorVal [IntegerVal 4443216167825301798]], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_s64(UINT64_C(0x3da979903f7fe126));
      clear_neon_saturated();
      //  Expect: "result" = 3da979903f7fe126
      result = vreinterpret_f16_s64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         __fp16 got;
         __fp16 exp;
         got = vget_lane_f16(result, 0);
         exp = -659.0;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vget_lane_f16(result, 1);
         exp = 1.8740234375;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vget_lane_f16(result, 2);
         exp = 45568.0;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 2 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vget_lane_f16(result, 3);
         exp = 1.4150390625;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 3 ", exp, got);
            }
      }
   }
}
#endif
}
void dotests_2835() {
#if __ARM_NEON_FP16_INTRINSICS

{
   {
      float16x4_t arg1;
      int8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpret_s8_f16\", rettype = \"int8x8_t\", argtypes = \"[float16x4_t]\", vals = [VectorVal [FloatVal 5.652769562749667,FloatVal (-2.2611971200547814),FloatVal (-3.6686329470106216),FloatVal 1.6565096292925894]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_f16(UINT64_C(0x3ea0c356c08545a7));
      clear_neon_saturated();
      //  Expect: "result" = 3ea0c356c08545a7
      result = vreinterpret_s8_f16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s8(result), 0);
      exp = UINT64_C(0x3ea0c356c08545a7);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
#endif
}
void dotests_2836() {
#if __ARM_NEON_FP16_INTRINSICS

{
   {
      float16x4_t arg1;
      int16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpret_s16_f16\", rettype = \"int16x4_t\", argtypes = \"[float16x4_t]\", vals = [VectorVal [FloatVal (-9.49299108242176),FloatVal (-4.24733655102262),FloatVal (-2.9117397323025163),FloatVal (-8.010470329409872)]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_f16(UINT64_C(0xc801c1d2c43fc8bf));
      clear_neon_saturated();
      //  Expect: "result" = c801c1d2c43fc8bf
      result = vreinterpret_s16_f16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s16(result), 0);
      exp = UINT64_C(0xc801c1d2c43fc8bf);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
#endif
}
void dotests_2837() {
#if __ARM_NEON_FP16_INTRINSICS

{
   {
      float16x4_t arg1;
      int32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpret_s32_f16\", rettype = \"int32x2_t\", argtypes = \"[float16x4_t]\", vals = [VectorVal [FloatVal 2.1544832181761304,FloatVal (-1.8146743807636483),FloatVal 1.5284672464092743,FloatVal (-9.463797038818743)]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_f16(UINT64_C(0xc8bb3e1dbf42404f));
      clear_neon_saturated();
      //  Expect: "result" = c8bb3e1dbf42404f
      result = vreinterpret_s32_f16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s32(result), 0);
      exp = UINT64_C(0xc8bb3e1dbf42404f);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
#endif
}
void dotests_2838() {
#if __ARM_NEON_FP16_INTRINSICS

{
   {
      float16x4_t arg1;
      float32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpret_f32_f16\", rettype = \"float32x2_t\", argtypes = \"[float16x4_t]\", vals = [VectorVal [FloatVal 1026.0,FloatVal 1.822265625,FloatVal (-0.1092529296875),FloatVal 1.7451171875]], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_f16(UINT64_C(0x3efbaefe3f4a6402));
      clear_neon_saturated();
      //  Expect: "result" = 3efbaefe3f4a6402
      result = vreinterpret_f32_f16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result, 0);
         exp = ((float32_t) 0.7905884981155396);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result, 1);
         exp = ((float32_t) 0.491569459438324);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
   }
}
#endif
}
void dotests_2839() {
#if __ARM_NEON_FP16_INTRINSICS

{
   {
      float16x4_t arg1;
      uint8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpret_u8_f16\", rettype = \"uint8x8_t\", argtypes = \"[float16x4_t]\", vals = [VectorVal [FloatVal 5.961296075439824,FloatVal (-1.3941030840926558),FloatVal 7.543169344181528,FloatVal 9.421966344796814]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_f16(UINT64_C(0x48b6478bbd9345f6));
      clear_neon_saturated();
      //  Expect: "result" = 48b6478bbd9345f6
      result = vreinterpret_u8_f16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u8(result), 0);
      exp = UINT64_C(0x48b6478bbd9345f6);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
#endif
}
void dotests_2840() {
#if __ARM_NEON_FP16_INTRINSICS

{
   {
      float16x4_t arg1;
      uint16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpret_u16_f16\", rettype = \"uint16x4_t\", argtypes = \"[float16x4_t]\", vals = [VectorVal [FloatVal 5.133627909160465,FloatVal (-4.433985403249694),FloatVal 3.7907472955249073,FloatVal 3.3299201748747205]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_f16(UINT64_C(0x42a84394c46f4522));
      clear_neon_saturated();
      //  Expect: "result" = 42a84394c46f4522
      result = vreinterpret_u16_f16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u16(result), 0);
      exp = UINT64_C(0x42a84394c46f4522);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
#endif
}
void dotests_2841() {
#if __ARM_NEON_FP16_INTRINSICS

{
   {
      float16x4_t arg1;
      uint32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpret_u32_f16\", rettype = \"uint32x2_t\", argtypes = \"[float16x4_t]\", vals = [VectorVal [FloatVal (-5.219282894899049),FloatVal 9.592175209129092,FloatVal 8.087632481378193,FloatVal (-4.435033196775626)]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_f16(UINT64_C(0xc46f480b48cbc538));
      clear_neon_saturated();
      //  Expect: "result" = c46f480b48cbc538
      result = vreinterpret_u32_f16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u32(result), 0);
      exp = UINT64_C(0xc46f480b48cbc538);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
#endif
}
void dotests_2842() {
#if __ARM_NEON_FP16_INTRINSICS

{
   {
      float16x4_t arg1;
      poly8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpret_p8_f16\", rettype = \"poly8x8_t\", argtypes = \"[float16x4_t]\", vals = [VectorVal [FloatVal 8.552163053391027,FloatVal (-9.277490350416643),FloatVal (-1.0091852789358562),FloatVal (-7.06977021910231)]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_f16(UINT64_C(0xc711bc09c8a34846));
      clear_neon_saturated();
      //  Expect: "result" = c711bc09c8a34846
      result = vreinterpret_p8_f16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_p8(result), 0);
      exp = UINT64_C(0xc711bc09c8a34846);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
#endif
}
void dotests_2843() {
#if __ARM_NEON_FP16_INTRINSICS

{
   {
      float16x4_t arg1;
      poly16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpret_p16_f16\", rettype = \"poly16x4_t\", argtypes = \"[float16x4_t]\", vals = [VectorVal [FloatVal 2.2121107256421197,FloatVal (-0.7807059163100494),FloatVal 5.696280131912939,FloatVal 7.604937659225808]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_f16(UINT64_C(0x479a45b2ba3e406c));
      clear_neon_saturated();
      //  Expect: "result" = 479a45b2ba3e406c
      result = vreinterpret_p16_f16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_p16(result), 0);
      exp = UINT64_C(0x479a45b2ba3e406c);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
#endif
}
void dotests_2844() {
#if __ARM_NEON_FP16_INTRINSICS

{
   {
      float16x4_t arg1;
      uint64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpret_u64_f16\", rettype = \"uint64x1_t\", argtypes = \"[float16x4_t]\", vals = [VectorVal [FloatVal (-3.1639927818444598),FloatVal (-9.270803988404692),FloatVal (-2.445306186001284),FloatVal 8.127690456597104]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_f16(UINT64_C(0x4810c0e3c8a2c253));
      clear_neon_saturated();
      //  Expect: "result" = 4810c0e3c8a2c253
      result = vreinterpret_u64_f16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(result, 0);
      exp = UINT64_C(0x4810c0e3c8a2c253);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
#endif
}
void dotests_2845() {
#if __ARM_NEON_FP16_INTRINSICS

{
   {
      float16x4_t arg1;
      int64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpret_s64_f16\", rettype = \"int64x1_t\", argtypes = \"[float16x4_t]\", vals = [VectorVal [FloatVal (-2.4545766092154935),FloatVal 7.513876829408389,FloatVal 5.426580235159575,FloatVal 8.501320598251489]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_f16(UINT64_C(0x4840456d4783c0e8));
      clear_neon_saturated();
      //  Expect: "result" = 4840456d4783c0e8
      result = vreinterpret_s64_f16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s64(result), 0);
      exp = UINT64_C(0x4840456d4783c0e8);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
#endif
}
void dotests_2846() {

{
   {
      int8x16_t arg1;
      int16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpretq_s16_s8\", rettype = \"int16x8_t\", argtypes = \"[int8x16_t]\", vals = [VectorVal [IntegerVal 0,IntegerVal (-106),IntegerVal (-128),IntegerVal (-1),IntegerVal (-1),IntegerVal 127,IntegerVal 0,IntegerVal 0,IntegerVal 127,IntegerVal (-31),IntegerVal 127,IntegerVal 120,IntegerVal (-1),IntegerVal 55,IntegerVal (-124),IntegerVal (-128)]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s8(vcreate_s8(UINT64_C(0x00007fffff809600)),
                         vcreate_s8(UINT64_C(0x808437ff787fe17f)));
      clear_neon_saturated();
      //  Expect: "result" = 808437ff787fe17f00007fffff809600
      result = vreinterpretq_s16_s8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 0);
         exp = UINT64_C(0x00007fffff809600);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 1);
         exp = UINT64_C(0x808437ff787fe17f);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2847() {

{
   {
      int8x16_t arg1;
      int32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpretq_s32_s8\", rettype = \"int32x4_t\", argtypes = \"[int8x16_t]\", vals = [VectorVal [IntegerVal (-4),IntegerVal 0,IntegerVal (-128),IntegerVal 0,IntegerVal (-1),IntegerVal (-128),IntegerVal 127,IntegerVal (-1),IntegerVal 127,IntegerVal 0,IntegerVal 127,IntegerVal 127,IntegerVal (-128),IntegerVal 127,IntegerVal (-1),IntegerVal (-128)]], start_saturated = True}";
      int reported = 0;
      arg1 = vcombine_s8(vcreate_s8(UINT64_C(0xff7f80ff008000fc)),
                         vcreate_s8(UINT64_C(0x80ff7f807f7f007f)));
      set_neon_saturated();
      //  Expect: "result" = 80ff7f807f7f007fff7f80ff008000fc
      result = vreinterpretq_s32_s8(arg1);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 0);
         exp = UINT64_C(0xff7f80ff008000fc);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 1);
         exp = UINT64_C(0x80ff7f807f7f007f);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2848() {

{
   {
      int8x16_t arg1;
      float32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpretq_f32_s8\", rettype = \"float32x4_t\", argtypes = \"[int8x16_t]\", vals = [VectorVal [IntegerVal 68,IntegerVal 85,IntegerVal 13,IntegerVal 63,IntegerVal (-39),IntegerVal (-55),IntegerVal 5,IntegerVal 63,IntegerVal 79,IntegerVal (-88),IntegerVal 103,IntegerVal 63,IntegerVal 70,IntegerVal (-109),IntegerVal 31,IntegerVal 63]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s8(vcreate_s8(UINT64_C(0x3f05c9d93f0d5544)),
                         vcreate_s8(UINT64_C(0x3f1f93463f67a84f)));
      clear_neon_saturated();
      //  Expect: "result" = 3f1f93463f67a84f3f05c9d93f0d5544
      result = vreinterpretq_f32_s8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 0);
         exp = ((float32_t) 0.5520823001861572);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 1);
         exp = ((float32_t) 0.5226112008094788);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 2);
         exp = ((float32_t) 0.9049119353294373);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 2 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 3);
         exp = ((float32_t) 0.6233409643173218);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 3 ", exp, got);
            }
      }
   }
}
}
void dotests_2849() {

{
   {
      int8x16_t arg1;
      uint8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpretq_u8_s8\", rettype = \"uint8x16_t\", argtypes = \"[int8x16_t]\", vals = [VectorVal [IntegerVal 27,IntegerVal (-49),IntegerVal 127,IntegerVal 0,IntegerVal (-1),IntegerVal 0,IntegerVal 0,IntegerVal (-50),IntegerVal 112,IntegerVal (-1),IntegerVal (-8),IntegerVal (-128),IntegerVal (-61),IntegerVal (-108),IntegerVal 0,IntegerVal (-27)]], start_saturated = True}";
      int reported = 0;
      arg1 = vcombine_s8(vcreate_s8(UINT64_C(0xce0000ff007fcf1b)),
                         vcreate_s8(UINT64_C(0xe50094c380f8ff70)));
      set_neon_saturated();
      //  Expect: "result" = e50094c380f8ff70ce0000ff007fcf1b
      result = vreinterpretq_u8_s8(arg1);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 0);
         exp = UINT64_C(0xce0000ff007fcf1b);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 1);
         exp = UINT64_C(0xe50094c380f8ff70);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2850() {

{
   {
      int8x16_t arg1;
      uint16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpretq_u16_s8\", rettype = \"uint16x8_t\", argtypes = \"[int8x16_t]\", vals = [VectorVal [IntegerVal (-128),IntegerVal (-128),IntegerVal 20,IntegerVal 0,IntegerVal (-1),IntegerVal (-52),IntegerVal 0,IntegerVal 127,IntegerVal 0,IntegerVal 127,IntegerVal (-128),IntegerVal (-128),IntegerVal (-1),IntegerVal 0,IntegerVal (-128),IntegerVal 89]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s8(vcreate_s8(UINT64_C(0x7f00ccff00148080)),
                         vcreate_s8(UINT64_C(0x598000ff80807f00)));
      clear_neon_saturated();
      //  Expect: "result" = 598000ff80807f007f00ccff00148080
      result = vreinterpretq_u16_s8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 0);
         exp = UINT64_C(0x7f00ccff00148080);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 1);
         exp = UINT64_C(0x598000ff80807f00);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2851() {

{
   {
      int8x16_t arg1;
      uint32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpretq_u32_s8\", rettype = \"uint32x4_t\", argtypes = \"[int8x16_t]\", vals = [VectorVal [IntegerVal (-1),IntegerVal 127,IntegerVal 127,IntegerVal 18,IntegerVal 0,IntegerVal (-128),IntegerVal 127,IntegerVal 127,IntegerVal (-1),IntegerVal 0,IntegerVal 0,IntegerVal (-128),IntegerVal (-1),IntegerVal 127,IntegerVal 127,IntegerVal 47]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s8(vcreate_s8(UINT64_C(0x7f7f8000127f7fff)),
                         vcreate_s8(UINT64_C(0x2f7f7fff800000ff)));
      clear_neon_saturated();
      //  Expect: "result" = 2f7f7fff800000ff7f7f8000127f7fff
      result = vreinterpretq_u32_s8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 0);
         exp = UINT64_C(0x7f7f8000127f7fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 1);
         exp = UINT64_C(0x2f7f7fff800000ff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2852() {

{
   {
      int8x16_t arg1;
      poly8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpretq_p8_s8\", rettype = \"poly8x16_t\", argtypes = \"[int8x16_t]\", vals = [VectorVal [IntegerVal (-1),IntegerVal (-52),IntegerVal (-1),IntegerVal 0,IntegerVal 118,IntegerVal (-128),IntegerVal 0,IntegerVal 0,IntegerVal 0,IntegerVal 0,IntegerVal 127,IntegerVal 0,IntegerVal 0,IntegerVal (-87),IntegerVal 127,IntegerVal 0]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s8(vcreate_s8(UINT64_C(0x0000807600ffccff)),
                         vcreate_s8(UINT64_C(0x007fa900007f0000)));
      clear_neon_saturated();
      //  Expect: "result" = 007fa900007f00000000807600ffccff
      result = vreinterpretq_p8_s8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p8(result), 0);
         exp = UINT64_C(0x0000807600ffccff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p8(result), 1);
         exp = UINT64_C(0x007fa900007f0000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2853() {

{
   {
      int8x16_t arg1;
      poly16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpretq_p16_s8\", rettype = \"poly16x8_t\", argtypes = \"[int8x16_t]\", vals = [VectorVal [IntegerVal (-128),IntegerVal 127,IntegerVal (-128),IntegerVal 0,IntegerVal 7,IntegerVal (-1),IntegerVal 0,IntegerVal (-128),IntegerVal 69,IntegerVal 0,IntegerVal (-128),IntegerVal 45,IntegerVal 0,IntegerVal (-1),IntegerVal (-45),IntegerVal (-128)]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s8(vcreate_s8(UINT64_C(0x8000ff0700807f80)),
                         vcreate_s8(UINT64_C(0x80d3ff002d800045)));
      clear_neon_saturated();
      //  Expect: "result" = 80d3ff002d8000458000ff0700807f80
      result = vreinterpretq_p16_s8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p16(result), 0);
         exp = UINT64_C(0x8000ff0700807f80);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p16(result), 1);
         exp = UINT64_C(0x80d3ff002d800045);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2854() {

{
   {
      int8x16_t arg1;
      uint64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpretq_u64_s8\", rettype = \"uint64x2_t\", argtypes = \"[int8x16_t]\", vals = [VectorVal [IntegerVal 0,IntegerVal 0,IntegerVal 0,IntegerVal (-28),IntegerVal 43,IntegerVal (-1),IntegerVal (-128),IntegerVal (-118),IntegerVal 0,IntegerVal (-128),IntegerVal 62,IntegerVal 127,IntegerVal (-128),IntegerVal 0,IntegerVal (-1),IntegerVal (-1)]], start_saturated = True}";
      int reported = 0;
      arg1 = vcombine_s8(vcreate_s8(UINT64_C(0x8a80ff2be4000000)),
                         vcreate_s8(UINT64_C(0xffff00807f3e8000)));
      set_neon_saturated();
      //  Expect: "result" = ffff00807f3e80008a80ff2be4000000
      result = vreinterpretq_u64_s8(arg1);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 0);
         exp = UINT64_C(0x8a80ff2be4000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 1);
         exp = UINT64_C(0xffff00807f3e8000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2855() {

{
   {
      int8x16_t arg1;
      int64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpretq_s64_s8\", rettype = \"int64x2_t\", argtypes = \"[int8x16_t]\", vals = [VectorVal [IntegerVal 127,IntegerVal (-1),IntegerVal 0,IntegerVal (-1),IntegerVal 127,IntegerVal 91,IntegerVal (-128),IntegerVal (-119),IntegerVal 0,IntegerVal (-1),IntegerVal 75,IntegerVal (-105),IntegerVal 127,IntegerVal 127,IntegerVal (-128),IntegerVal (-128)]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s8(vcreate_s8(UINT64_C(0x89805b7fff00ff7f)),
                         vcreate_s8(UINT64_C(0x80807f7f974bff00)));
      clear_neon_saturated();
      //  Expect: "result" = 80807f7f974bff0089805b7fff00ff7f
      result = vreinterpretq_s64_s8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 0);
         exp = UINT64_C(0x89805b7fff00ff7f);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 1);
         exp = UINT64_C(0x80807f7f974bff00);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2856() {
#if __ARM_NEON_FP16_INTRINSICS

{
   {
      int8x16_t arg1;
      float16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpretq_f16_s8\", rettype = \"float16x8_t\", argtypes = \"[int8x16_t]\", vals = [VectorVal [IntegerVal 37,IntegerVal (-114),IntegerVal 114,IntegerVal 63,IntegerVal (-57),IntegerVal 107,IntegerVal 79,IntegerVal 63,IntegerVal 16,IntegerVal (-109),IntegerVal (-6),IntegerVal 61,IntegerVal 120,IntegerVal (-16),IntegerVal 105,IntegerVal 63]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s8(vcreate_s8(UINT64_C(0x3f4f6bc73f728e25)),
                         vcreate_s8(UINT64_C(0x3f69f0783dfa9310)));
      clear_neon_saturated();
      //  Expect: "result" = 3f69f0783dfa93103f4f6bc73f728e25
      result = vreinterpretq_f16_s8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result, 0);
         exp = -3.750324249267578e-4;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result, 1);
         exp = 1.861328125;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result, 2);
         exp = 3982.0;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 2 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result, 3);
         exp = 1.8271484375;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 3 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result, 4);
         exp = -8.6212158203125e-4;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 4 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result, 5);
         exp = 1.494140625;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 5 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result, 6);
         exp = -9152.0;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 6 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result, 7);
         exp = 1.8525390625;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 7 ", exp, got);
            }
      }
   }
}
#endif
}
void dotests_2857() {

{
   {
      int16x8_t arg1;
      int8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpretq_s8_s16\", rettype = \"int8x16_t\", argtypes = \"[int16x8_t]\", vals = [VectorVal [IntegerVal (-1),IntegerVal (-32768),IntegerVal (-32768),IntegerVal 32767,IntegerVal (-32768),IntegerVal 32767,IntegerVal 0,IntegerVal 32767]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s16(vcreate_s16(UINT64_C(0x7fff80008000ffff)),
                          vcreate_s16(UINT64_C(0x7fff00007fff8000)));
      clear_neon_saturated();
      //  Expect: "result" = 7fff00007fff80007fff80008000ffff
      result = vreinterpretq_s8_s16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result), 0);
         exp = UINT64_C(0x7fff80008000ffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result), 1);
         exp = UINT64_C(0x7fff00007fff8000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2858() {

{
   {
      int16x8_t arg1;
      int32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpretq_s32_s16\", rettype = \"int32x4_t\", argtypes = \"[int16x8_t]\", vals = [VectorVal [IntegerVal 0,IntegerVal 5367,IntegerVal (-32768),IntegerVal 0,IntegerVal 32767,IntegerVal (-16104),IntegerVal (-1),IntegerVal 0]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s16(vcreate_s16(UINT64_C(0x0000800014f70000)),
                          vcreate_s16(UINT64_C(0x0000ffffc1187fff)));
      clear_neon_saturated();
      //  Expect: "result" = 0000ffffc1187fff0000800014f70000
      result = vreinterpretq_s32_s16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 0);
         exp = UINT64_C(0x0000800014f70000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 1);
         exp = UINT64_C(0x0000ffffc1187fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2859() {

{
   {
      int16x8_t arg1;
      float32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpretq_f32_s16\", rettype = \"float32x4_t\", argtypes = \"[int16x8_t]\", vals = [VectorVal [IntegerVal 1419,IntegerVal 16234,IntegerVal 619,IntegerVal 16195,IntegerVal (-5769),IntegerVal 16185,IntegerVal (-7544),IntegerVal 15791]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s16(vcreate_s16(UINT64_C(0x3f43026b3f6a058b)),
                          vcreate_s16(UINT64_C(0x3dafe2883f39e977)));
      clear_neon_saturated();
      //  Expect: "result" = 3dafe2883f39e9773f43026b3f6a058b
      result = vreinterpretq_f32_s16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 0);
         exp = ((float32_t) 0.9141470789909363);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 1);
         exp = ((float32_t) 0.761755645275116);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 2);
         exp = ((float32_t) 0.7262186408042908);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 2 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 3);
         exp = ((float32_t) 8.58812928199768e-2);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 3 ", exp, got);
            }
      }
   }
}
}
void dotests_2860() {

{
   {
      int16x8_t arg1;
      uint8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpretq_u8_s16\", rettype = \"uint8x16_t\", argtypes = \"[int16x8_t]\", vals = [VectorVal [IntegerVal 32767,IntegerVal (-32768),IntegerVal (-10769),IntegerVal (-1),IntegerVal 0,IntegerVal 32767,IntegerVal 0,IntegerVal 0]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s16(vcreate_s16(UINT64_C(0xffffd5ef80007fff)),
                          vcreate_s16(UINT64_C(0x000000007fff0000)));
      clear_neon_saturated();
      //  Expect: "result" = 000000007fff0000ffffd5ef80007fff
      result = vreinterpretq_u8_s16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 0);
         exp = UINT64_C(0xffffd5ef80007fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 1);
         exp = UINT64_C(0x000000007fff0000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2861() {

{
   {
      int16x8_t arg1;
      uint16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpretq_u16_s16\", rettype = \"uint16x8_t\", argtypes = \"[int16x8_t]\", vals = [VectorVal [IntegerVal 0,IntegerVal (-32768),IntegerVal (-32768),IntegerVal 0,IntegerVal (-1),IntegerVal (-32768),IntegerVal (-32768),IntegerVal (-12431)]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s16(vcreate_s16(UINT64_C(0x0000800080000000)),
                          vcreate_s16(UINT64_C(0xcf7180008000ffff)));
      clear_neon_saturated();
      //  Expect: "result" = cf7180008000ffff0000800080000000
      result = vreinterpretq_u16_s16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 0);
         exp = UINT64_C(0x0000800080000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 1);
         exp = UINT64_C(0xcf7180008000ffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2862() {

{
   {
      int16x8_t arg1;
      uint32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpretq_u32_s16\", rettype = \"uint32x4_t\", argtypes = \"[int16x8_t]\", vals = [VectorVal [IntegerVal 0,IntegerVal (-32768),IntegerVal (-32768),IntegerVal (-32768),IntegerVal 0,IntegerVal 0,IntegerVal (-1),IntegerVal (-32768)]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s16(vcreate_s16(UINT64_C(0x8000800080000000)),
                          vcreate_s16(UINT64_C(0x8000ffff00000000)));
      clear_neon_saturated();
      //  Expect: "result" = 8000ffff000000008000800080000000
      result = vreinterpretq_u32_s16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 0);
         exp = UINT64_C(0x8000800080000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 1);
         exp = UINT64_C(0x8000ffff00000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2863() {

{
   {
      int16x8_t arg1;
      poly8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpretq_p8_s16\", rettype = \"poly8x16_t\", argtypes = \"[int16x8_t]\", vals = [VectorVal [IntegerVal (-32768),IntegerVal 28418,IntegerVal (-32768),IntegerVal 32767,IntegerVal 32767,IntegerVal 0,IntegerVal 0,IntegerVal (-1)]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s16(vcreate_s16(UINT64_C(0x7fff80006f028000)),
                          vcreate_s16(UINT64_C(0xffff000000007fff)));
      clear_neon_saturated();
      //  Expect: "result" = ffff000000007fff7fff80006f028000
      result = vreinterpretq_p8_s16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p8(result), 0);
         exp = UINT64_C(0x7fff80006f028000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p8(result), 1);
         exp = UINT64_C(0xffff000000007fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2864() {

{
   {
      int16x8_t arg1;
      poly16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpretq_p16_s16\", rettype = \"poly16x8_t\", argtypes = \"[int16x8_t]\", vals = [VectorVal [IntegerVal (-1),IntegerVal 0,IntegerVal 32767,IntegerVal (-32768),IntegerVal (-32768),IntegerVal (-3424),IntegerVal 0,IntegerVal (-24846)]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s16(vcreate_s16(UINT64_C(0x80007fff0000ffff)),
                          vcreate_s16(UINT64_C(0x9ef20000f2a08000)));
      clear_neon_saturated();
      //  Expect: "result" = 9ef20000f2a0800080007fff0000ffff
      result = vreinterpretq_p16_s16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p16(result), 0);
         exp = UINT64_C(0x80007fff0000ffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p16(result), 1);
         exp = UINT64_C(0x9ef20000f2a08000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2865() {

{
   {
      int16x8_t arg1;
      uint64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpretq_u64_s16\", rettype = \"uint64x2_t\", argtypes = \"[int16x8_t]\", vals = [VectorVal [IntegerVal 22384,IntegerVal 32767,IntegerVal 0,IntegerVal (-32768),IntegerVal (-32768),IntegerVal 32767,IntegerVal (-32768),IntegerVal 0]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s16(vcreate_s16(UINT64_C(0x800000007fff5770)),
                          vcreate_s16(UINT64_C(0x000080007fff8000)));
      clear_neon_saturated();
      //  Expect: "result" = 000080007fff8000800000007fff5770
      result = vreinterpretq_u64_s16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 0);
         exp = UINT64_C(0x800000007fff5770);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 1);
         exp = UINT64_C(0x000080007fff8000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2866() {

{
   {
      int16x8_t arg1;
      int64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpretq_s64_s16\", rettype = \"int64x2_t\", argtypes = \"[int16x8_t]\", vals = [VectorVal [IntegerVal (-16311),IntegerVal (-32768),IntegerVal (-31332),IntegerVal 20903,IntegerVal (-6719),IntegerVal 0,IntegerVal 0,IntegerVal 0]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s16(vcreate_s16(UINT64_C(0x51a7859c8000c049)),
                          vcreate_s16(UINT64_C(0x000000000000e5c1)));
      clear_neon_saturated();
      //  Expect: "result" = 000000000000e5c151a7859c8000c049
      result = vreinterpretq_s64_s16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 0);
         exp = UINT64_C(0x51a7859c8000c049);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 1);
         exp = UINT64_C(0x000000000000e5c1);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2867() {
#if __ARM_NEON_FP16_INTRINSICS

{
   {
      int16x8_t arg1;
      float16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpretq_f16_s16\", rettype = \"float16x8_t\", argtypes = \"[int16x8_t]\", vals = [VectorVal [IntegerVal (-24012),IntegerVal 16171,IntegerVal 2290,IntegerVal 16088,IntegerVal 15661,IntegerVal 16155,IntegerVal (-6464),IntegerVal 15491]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s16(vcreate_s16(UINT64_C(0x3ed808f23f2ba234)),
                          vcreate_s16(UINT64_C(0x3c83e6c03f1b3d2d)));
      clear_neon_saturated();
      //  Expect: "result" = 3c83e6c03f1b3d2d3ed808f23f2ba234
      result = vreinterpretq_f16_s16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result, 0);
         exp = -1.2115478515625e-2;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result, 1);
         exp = 1.7919921875;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result, 2);
         exp = 1.5091896057128906e-4;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 2 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result, 3);
         exp = 1.7109375;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 3 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result, 4);
         exp = 1.2939453125;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 4 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result, 5);
         exp = 1.7763671875;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 5 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result, 6);
         exp = -1728.0;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 6 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result, 7);
         exp = 1.1279296875;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 7 ", exp, got);
            }
      }
   }
}
#endif
}
void dotests_2868() {

{
   {
      int32x4_t arg1;
      int8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpretq_s8_s32\", rettype = \"int8x16_t\", argtypes = \"[int32x4_t]\", vals = [VectorVal [IntegerVal 32767,IntegerVal (-65536),IntegerVal (-32768),IntegerVal (-32768)]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s32(vcreate_s32(UINT64_C(0xffff000000007fff)),
                          vcreate_s32(UINT64_C(0xffff8000ffff8000)));
      clear_neon_saturated();
      //  Expect: "result" = ffff8000ffff8000ffff000000007fff
      result = vreinterpretq_s8_s32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result), 0);
         exp = UINT64_C(0xffff000000007fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result), 1);
         exp = UINT64_C(0xffff8000ffff8000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2869() {

{
   {
      int32x4_t arg1;
      int16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpretq_s16_s32\", rettype = \"int16x8_t\", argtypes = \"[int32x4_t]\", vals = [VectorVal [IntegerVal 2147450880,IntegerVal (-1165459456),IntegerVal (-32769),IntegerVal (-1451327488)]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s32(vcreate_s32(UINT64_C(0xba8880007fff8000)),
                          vcreate_s32(UINT64_C(0xa97e8000ffff7fff)));
      clear_neon_saturated();
      //  Expect: "result" = a97e8000ffff7fffba8880007fff8000
      result = vreinterpretq_s16_s32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 0);
         exp = UINT64_C(0xba8880007fff8000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 1);
         exp = UINT64_C(0xa97e8000ffff7fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2870() {

{
   {
      int32x4_t arg1;
      float32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpretq_f32_s32\", rettype = \"float32x4_t\", argtypes = \"[int32x4_t]\", vals = [VectorVal [IntegerVal 1047972044,IntegerVal 1057722888,IntegerVal 1054168930,IntegerVal 1060402758]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s32(vcreate_s32(UINT64_C(0x3f0b92083e76c8cc)),
                          vcreate_s32(UINT64_C(0x3f3476463ed55762)));
      clear_neon_saturated();
      //  Expect: "result" = 3f3476463ed557623f0b92083e76c8cc
      result = vreinterpretq_f32_s32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 0);
         exp = ((float32_t) 0.24100035429000854);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 1);
         exp = ((float32_t) 0.5451970100402832);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 2);
         exp = ((float32_t) 0.41668230295181274);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 2 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 3);
         exp = ((float32_t) 0.7049297094345093);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 3 ", exp, got);
            }
      }
   }
}
}
void dotests_2871() {

{
   {
      int32x4_t arg1;
      uint8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpretq_u8_s32\", rettype = \"uint8x16_t\", argtypes = \"[int32x4_t]\", vals = [VectorVal [IntegerVal (-1),IntegerVal (-2147450881),IntegerVal (-65536),IntegerVal 875692031]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s32(vcreate_s32(UINT64_C(0x80007fffffffffff)),
                          vcreate_s32(UINT64_C(0x3431ffffffff0000)));
      clear_neon_saturated();
      //  Expect: "result" = 3431ffffffff000080007fffffffffff
      result = vreinterpretq_u8_s32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 0);
         exp = UINT64_C(0x80007fffffffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 1);
         exp = UINT64_C(0x3431ffffffff0000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2872() {

{
   {
      int32x4_t arg1;
      uint16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpretq_u16_s32\", rettype = \"uint16x8_t\", argtypes = \"[int32x4_t]\", vals = [VectorVal [IntegerVal (-2147450880),IntegerVal (-2147450880),IntegerVal (-65536),IntegerVal (-65536)]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s32(vcreate_s32(UINT64_C(0x8000800080008000)),
                          vcreate_s32(UINT64_C(0xffff0000ffff0000)));
      clear_neon_saturated();
      //  Expect: "result" = ffff0000ffff00008000800080008000
      result = vreinterpretq_u16_s32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 0);
         exp = UINT64_C(0x8000800080008000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 1);
         exp = UINT64_C(0xffff0000ffff0000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2873() {

{
   {
      int32x4_t arg1;
      uint32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpretq_u32_s32\", rettype = \"uint32x4_t\", argtypes = \"[int32x4_t]\", vals = [VectorVal [IntegerVal 65535,IntegerVal (-253296640),IntegerVal 2147450879,IntegerVal 0]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s32(vcreate_s32(UINT64_C(0xf0e700000000ffff)),
                          vcreate_s32(UINT64_C(0x000000007fff7fff)));
      clear_neon_saturated();
      //  Expect: "result" = 000000007fff7ffff0e700000000ffff
      result = vreinterpretq_u32_s32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 0);
         exp = UINT64_C(0xf0e700000000ffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 1);
         exp = UINT64_C(0x000000007fff7fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2874() {

{
   {
      int32x4_t arg1;
      poly8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpretq_p8_s32\", rettype = \"poly8x16_t\", argtypes = \"[int32x4_t]\", vals = [VectorVal [IntegerVal 2147450880,IntegerVal (-2147418113),IntegerVal (-65536),IntegerVal (-2147483648)]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s32(vcreate_s32(UINT64_C(0x8000ffff7fff8000)),
                          vcreate_s32(UINT64_C(0x80000000ffff0000)));
      clear_neon_saturated();
      //  Expect: "result" = 80000000ffff00008000ffff7fff8000
      result = vreinterpretq_p8_s32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p8(result), 0);
         exp = UINT64_C(0x8000ffff7fff8000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p8(result), 1);
         exp = UINT64_C(0x80000000ffff0000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2875() {

{
   {
      int32x4_t arg1;
      poly16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpretq_p16_s32\", rettype = \"poly16x8_t\", argtypes = \"[int32x4_t]\", vals = [VectorVal [IntegerVal (-2147450881),IntegerVal (-1126629376),IntegerVal (-32769),IntegerVal (-27937)]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s32(vcreate_s32(UINT64_C(0xbcd9000080007fff)),
                          vcreate_s32(UINT64_C(0xffff92dfffff7fff)));
      clear_neon_saturated();
      //  Expect: "result" = ffff92dfffff7fffbcd9000080007fff
      result = vreinterpretq_p16_s32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p16(result), 0);
         exp = UINT64_C(0xbcd9000080007fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p16(result), 1);
         exp = UINT64_C(0xffff92dfffff7fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2876() {

{
   {
      int32x4_t arg1;
      uint64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpretq_u64_s32\", rettype = \"uint64x2_t\", argtypes = \"[int32x4_t]\", vals = [VectorVal [IntegerVal 65535,IntegerVal 0,IntegerVal (-2147446378),IntegerVal 9275]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s32(vcreate_s32(UINT64_C(0x000000000000ffff)),
                          vcreate_s32(UINT64_C(0x0000243b80009196)));
      clear_neon_saturated();
      //  Expect: "result" = 0000243b80009196000000000000ffff
      result = vreinterpretq_u64_s32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 0);
         exp = UINT64_C(0x000000000000ffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 1);
         exp = UINT64_C(0x0000243b80009196);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2877() {

{
   {
      int32x4_t arg1;
      int64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpretq_s64_s32\", rettype = \"int64x2_t\", argtypes = \"[int32x4_t]\", vals = [VectorVal [IntegerVal (-2147450881),IntegerVal (-65536),IntegerVal (-655228928),IntegerVal 2147430617]], start_saturated = True}";
      int reported = 0;
      arg1 = vcombine_s32(vcreate_s32(UINT64_C(0xffff000080007fff)),
                          vcreate_s32(UINT64_C(0x7fff30d9d8f20000)));
      set_neon_saturated();
      //  Expect: "result" = 7fff30d9d8f20000ffff000080007fff
      result = vreinterpretq_s64_s32(arg1);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 0);
         exp = UINT64_C(0xffff000080007fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 1);
         exp = UINT64_C(0x7fff30d9d8f20000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2878() {
#if __ARM_NEON_FP16_INTRINSICS

{
   {
      int32x4_t arg1;
      float16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpretq_f16_s32\", rettype = \"float16x8_t\", argtypes = \"[int32x4_t]\", vals = [VectorVal [IntegerVal 1065003968,IntegerVal 1049063850,IntegerVal 1054359438,IntegerVal 1032396392]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s32(vcreate_s32(UINT64_C(0x3e8771aa3f7aabc0)),
                          vcreate_s32(UINT64_C(0x3d891e683ed83f8e)));
      clear_neon_saturated();
      //  Expect: "result" = 3d891e683ed83f8e3e8771aa3f7aabc0
      result = vreinterpretq_f16_s32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result, 0);
         exp = -6.0546875e-2;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result, 1);
         exp = 1.869140625;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result, 2);
         exp = 11600.0;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 2 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result, 3);
         exp = 1.6318359375;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 3 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result, 4);
         exp = 1.888671875;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 4 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result, 5);
         exp = 1.7109375;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 5 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result, 6);
         exp = 6.256103515625e-3;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 6 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result, 7);
         exp = 1.3837890625;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 7 ", exp, got);
            }
      }
   }
}
#endif
}
void dotests_2879() {

{
   {
      float32x4_t arg1;
      int8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpretq_s8_f32\", rettype = \"int8x16_t\", argtypes = \"[float32x4_t]\", vals = [VectorVal [FloatVal 0.6677314639091492,FloatVal 0.7915223836898804,FloatVal 0.5378847718238831,FloatVal 0.8217608332633972]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_f32(vcreate_f32(UINT64_C(0x3f4aa1363f2af073)),
                          vcreate_f32(UINT64_C(0x3f525eeb3f09b2d1)));
      clear_neon_saturated();
      //  Expect: "result" = 3f525eeb3f09b2d13f4aa1363f2af073
      result = vreinterpretq_s8_f32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result), 0);
         exp = UINT64_C(0x3f4aa1363f2af073);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result), 1);
         exp = UINT64_C(0x3f525eeb3f09b2d1);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2880() {

{
   {
      float32x4_t arg1;
      int16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpretq_s16_f32\", rettype = \"int16x8_t\", argtypes = \"[float32x4_t]\", vals = [VectorVal [FloatVal 0.9377423524856567,FloatVal 0.7647671103477478,FloatVal 0.1299220323562622,FloatVal 0.6479869484901428]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_f32(vcreate_f32(UINT64_C(0x3f43c7c73f700fe2)),
                          vcreate_f32(UINT64_C(0x3f25e2793e050a48)));
      clear_neon_saturated();
      //  Expect: "result" = 3f25e2793e050a483f43c7c73f700fe2
      result = vreinterpretq_s16_f32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 0);
         exp = UINT64_C(0x3f43c7c73f700fe2);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 1);
         exp = UINT64_C(0x3f25e2793e050a48);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2881() {

{
   {
      float32x4_t arg1;
      int32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpretq_s32_f32\", rettype = \"int32x4_t\", argtypes = \"[float32x4_t]\", vals = [VectorVal [FloatVal 0.18986356258392334,FloatVal 0.10544180870056152,FloatVal 0.7986879944801331,FloatVal 0.9743452668190002]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_f32(vcreate_f32(UINT64_C(0x3dd7f1e03e426b98)),
                          vcreate_f32(UINT64_C(0x3f796eb13f4c76d1)));
      clear_neon_saturated();
      //  Expect: "result" = 3f796eb13f4c76d13dd7f1e03e426b98
      result = vreinterpretq_s32_f32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 0);
         exp = UINT64_C(0x3dd7f1e03e426b98);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 1);
         exp = UINT64_C(0x3f796eb13f4c76d1);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2882() {

{
   {
      float32x4_t arg1;
      uint8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpretq_u8_f32\", rettype = \"uint8x16_t\", argtypes = \"[float32x4_t]\", vals = [VectorVal [FloatVal 0.9729787111282349,FloatVal 0.8634897470474243,FloatVal 0.19505983591079712,FloatVal 8.0768883228302e-2]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_f32(vcreate_f32(UINT64_C(0x3f5d0daa3f791522)),
                          vcreate_f32(UINT64_C(0x3da56a283e47bdc4)));
      clear_neon_saturated();
      //  Expect: "result" = 3da56a283e47bdc43f5d0daa3f791522
      result = vreinterpretq_u8_f32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 0);
         exp = UINT64_C(0x3f5d0daa3f791522);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 1);
         exp = UINT64_C(0x3da56a283e47bdc4);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2883() {

{
   {
      float32x4_t arg1;
      uint16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpretq_u16_f32\", rettype = \"uint16x8_t\", argtypes = \"[float32x4_t]\", vals = [VectorVal [FloatVal 0.16607940196990967,FloatVal 0.345866858959198,FloatVal 0.6731463670730591,FloatVal 0.8852851390838623]], start_saturated = True}";
      int reported = 0;
      arg1 = vcombine_f32(vcreate_f32(UINT64_C(0x3eb115763e2a10b8)),
                          vcreate_f32(UINT64_C(0x3f62a20c3f2c5352)));
      set_neon_saturated();
      //  Expect: "result" = 3f62a20c3f2c53523eb115763e2a10b8
      result = vreinterpretq_u16_f32(arg1);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 0);
         exp = UINT64_C(0x3eb115763e2a10b8);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 1);
         exp = UINT64_C(0x3f62a20c3f2c5352);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2884() {

{
   {
      float32x4_t arg1;
      uint32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpretq_u32_f32\", rettype = \"uint32x4_t\", argtypes = \"[float32x4_t]\", vals = [VectorVal [FloatVal 0.5404290556907654,FloatVal 0.9197194576263428,FloatVal 0.5985815525054932,FloatVal 0.7804642915725708]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_f32(vcreate_f32(UINT64_C(0x3f6b72bc3f0a598f)),
                          vcreate_f32(UINT64_C(0x3f47cc823f193ca4)));
      clear_neon_saturated();
      //  Expect: "result" = 3f47cc823f193ca43f6b72bc3f0a598f
      result = vreinterpretq_u32_f32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 0);
         exp = UINT64_C(0x3f6b72bc3f0a598f);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 1);
         exp = UINT64_C(0x3f47cc823f193ca4);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2885() {

{
   {
      float32x4_t arg1;
      poly8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpretq_p8_f32\", rettype = \"poly8x16_t\", argtypes = \"[float32x4_t]\", vals = [VectorVal [FloatVal 0.260110080242157,FloatVal 0.6197664737701416,FloatVal 0.8097567558288574,FloatVal 0.25640302896499634]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_f32(vcreate_f32(UINT64_C(0x3f1ea9043e852d26)),
                          vcreate_f32(UINT64_C(0x3e8347423f4f4c38)));
      clear_neon_saturated();
      //  Expect: "result" = 3e8347423f4f4c383f1ea9043e852d26
      result = vreinterpretq_p8_f32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p8(result), 0);
         exp = UINT64_C(0x3f1ea9043e852d26);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p8(result), 1);
         exp = UINT64_C(0x3e8347423f4f4c38);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2886() {

{
   {
      float32x4_t arg1;
      poly16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpretq_p16_f32\", rettype = \"poly16x8_t\", argtypes = \"[float32x4_t]\", vals = [VectorVal [FloatVal 0.6980897188186646,FloatVal 0.904854953289032,FloatVal 0.8915038108825684,FloatVal 0.6312646269798279]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_f32(vcreate_f32(UINT64_C(0x3f67a4933f32b602)),
                          vcreate_f32(UINT64_C(0x3f219a8f3f643998)));
      clear_neon_saturated();
      //  Expect: "result" = 3f219a8f3f6439983f67a4933f32b602
      result = vreinterpretq_p16_f32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p16(result), 0);
         exp = UINT64_C(0x3f67a4933f32b602);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p16(result), 1);
         exp = UINT64_C(0x3f219a8f3f643998);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2887() {

{
   {
      float32x4_t arg1;
      uint64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpretq_u64_f32\", rettype = \"uint64x2_t\", argtypes = \"[float32x4_t]\", vals = [VectorVal [FloatVal 0.8877594470977783,FloatVal 0.6092302203178406,FloatVal 0.2720602750778198,FloatVal 0.4687288999557495]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_f32(vcreate_f32(UINT64_C(0x3f1bf6833f634434)),
                          vcreate_f32(UINT64_C(0x3eeffd3c3e8b4b7c)));
      clear_neon_saturated();
      //  Expect: "result" = 3eeffd3c3e8b4b7c3f1bf6833f634434
      result = vreinterpretq_u64_f32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 0);
         exp = UINT64_C(0x3f1bf6833f634434);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 1);
         exp = UINT64_C(0x3eeffd3c3e8b4b7c);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2888() {

{
   {
      float32x4_t arg1;
      int64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpretq_s64_f32\", rettype = \"int64x2_t\", argtypes = \"[float32x4_t]\", vals = [VectorVal [FloatVal 0.3986346125602722,FloatVal 0.9880563020706177,FloatVal 4.971587657928467e-2,FloatVal 0.8282657265663147]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_f32(vcreate_f32(UINT64_C(0x3f7cf1423ecc19d6)),
                          vcreate_f32(UINT64_C(0x3f5409393d4ba2e0)));
      clear_neon_saturated();
      //  Expect: "result" = 3f5409393d4ba2e03f7cf1423ecc19d6
      result = vreinterpretq_s64_f32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 0);
         exp = UINT64_C(0x3f7cf1423ecc19d6);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 1);
         exp = UINT64_C(0x3f5409393d4ba2e0);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2889() {
#if __ARM_NEON_FP16_INTRINSICS

{
   {
      float32x4_t arg1;
      float16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpretq_f16_f32\", rettype = \"float16x8_t\", argtypes = \"[float32x4_t]\", vals = [VectorVal [FloatVal 0.1385800838470459,FloatVal 0.29417383670806885,FloatVal 0.5723680853843689,FloatVal 0.5229855179786682]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_f32(vcreate_f32(UINT64_C(0x3e969df43e0de7f0)),
                          vcreate_f32(UINT64_C(0x3f05e2613f1286b7)));
      clear_neon_saturated();
      //  Expect: "result" = 3f05e2613f1286b73e969df43e0de7f0
      result = vreinterpretq_f16_f32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result, 0);
         exp = -2032.0;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result, 1);
         exp = 1.5126953125;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result, 2);
         exp = -5.8135986328125e-3;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 2 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result, 3);
         exp = 1.646484375;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 3 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result, 4);
         exp = -1.0246038436889648e-4;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 4 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result, 5);
         exp = 1.767578125;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 5 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result, 6);
         exp = -816.5;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 6 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result, 7);
         exp = 1.7548828125;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 7 ", exp, got);
            }
      }
   }
}
#endif
}
void dotests_2890() {

{
   {
      uint8x16_t arg1;
      int8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpretq_s8_u8\", rettype = \"int8x16_t\", argtypes = \"[uint8x16_t]\", vals = [VectorVal [IntegerVal 0,IntegerVal 35,IntegerVal 255,IntegerVal 138,IntegerVal 127,IntegerVal 127,IntegerVal 0,IntegerVal 255,IntegerVal 7,IntegerVal 127,IntegerVal 197,IntegerVal 123,IntegerVal 128,IntegerVal 224,IntegerVal 255,IntegerVal 128]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u8(vcreate_u8(UINT64_C(0xff007f7f8aff2300)),
                         vcreate_u8(UINT64_C(0x80ffe0807bc57f07)));
      clear_neon_saturated();
      //  Expect: "result" = 80ffe0807bc57f07ff007f7f8aff2300
      result = vreinterpretq_s8_u8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result), 0);
         exp = UINT64_C(0xff007f7f8aff2300);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result), 1);
         exp = UINT64_C(0x80ffe0807bc57f07);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2891() {

{
   {
      uint8x16_t arg1;
      int16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpretq_s16_u8\", rettype = \"int16x8_t\", argtypes = \"[uint8x16_t]\", vals = [VectorVal [IntegerVal 255,IntegerVal 127,IntegerVal 255,IntegerVal 0,IntegerVal 127,IntegerVal 128,IntegerVal 128,IntegerVal 0,IntegerVal 166,IntegerVal 171,IntegerVal 127,IntegerVal 0,IntegerVal 127,IntegerVal 0,IntegerVal 0,IntegerVal 128]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u8(vcreate_u8(UINT64_C(0x0080807f00ff7fff)),
                         vcreate_u8(UINT64_C(0x8000007f007faba6)));
      clear_neon_saturated();
      //  Expect: "result" = 8000007f007faba60080807f00ff7fff
      result = vreinterpretq_s16_u8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 0);
         exp = UINT64_C(0x0080807f00ff7fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 1);
         exp = UINT64_C(0x8000007f007faba6);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2892() {

{
   {
      uint8x16_t arg1;
      int32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpretq_s32_u8\", rettype = \"int32x4_t\", argtypes = \"[uint8x16_t]\", vals = [VectorVal [IntegerVal 255,IntegerVal 7,IntegerVal 208,IntegerVal 128,IntegerVal 128,IntegerVal 127,IntegerVal 101,IntegerVal 115,IntegerVal 0,IntegerVal 127,IntegerVal 127,IntegerVal 127,IntegerVal 128,IntegerVal 221,IntegerVal 128,IntegerVal 255]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u8(vcreate_u8(UINT64_C(0x73657f8080d007ff)),
                         vcreate_u8(UINT64_C(0xff80dd807f7f7f00)));
      clear_neon_saturated();
      //  Expect: "result" = ff80dd807f7f7f0073657f8080d007ff
      result = vreinterpretq_s32_u8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 0);
         exp = UINT64_C(0x73657f8080d007ff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 1);
         exp = UINT64_C(0xff80dd807f7f7f00);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2893() {

{
   {
      uint8x16_t arg1;
      float32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpretq_f32_u8\", rettype = \"float32x4_t\", argtypes = \"[uint8x16_t]\", vals = [VectorVal [IntegerVal 110,IntegerVal 27,IntegerVal 160,IntegerVal 62,IntegerVal 255,IntegerVal 144,IntegerVal 40,IntegerVal 63,IntegerVal 245,IntegerVal 31,IntegerVal 75,IntegerVal 63,IntegerVal 224,IntegerVal 211,IntegerVal 250,IntegerVal 60]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u8(vcreate_u8(UINT64_C(0x3f2890ff3ea01b6e)),
                         vcreate_u8(UINT64_C(0x3cfad3e03f4b1ff5)));
      clear_neon_saturated();
      //  Expect: "result" = 3cfad3e03f4b1ff53f2890ff3ea01b6e
      result = vreinterpretq_f32_u8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 0);
         exp = ((float32_t) 0.3127092719078064);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 1);
         exp = ((float32_t) 0.6584624648094177);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 2);
         exp = ((float32_t) 0.7934563755989075);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 2 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 3);
         exp = ((float32_t) 3.0618607997894287e-2);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 3 ", exp, got);
            }
      }
   }
}
}
void dotests_2894() {

{
   {
      uint8x16_t arg1;
      uint16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpretq_u16_u8\", rettype = \"uint16x8_t\", argtypes = \"[uint8x16_t]\", vals = [VectorVal [IntegerVal 254,IntegerVal 128,IntegerVal 128,IntegerVal 127,IntegerVal 127,IntegerVal 255,IntegerVal 128,IntegerVal 255,IntegerVal 127,IntegerVal 0,IntegerVal 255,IntegerVal 0,IntegerVal 177,IntegerVal 148,IntegerVal 255,IntegerVal 128]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u8(vcreate_u8(UINT64_C(0xff80ff7f7f8080fe)),
                         vcreate_u8(UINT64_C(0x80ff94b100ff007f)));
      clear_neon_saturated();
      //  Expect: "result" = 80ff94b100ff007fff80ff7f7f8080fe
      result = vreinterpretq_u16_u8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 0);
         exp = UINT64_C(0xff80ff7f7f8080fe);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 1);
         exp = UINT64_C(0x80ff94b100ff007f);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2895() {

{
   {
      uint8x16_t arg1;
      uint32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpretq_u32_u8\", rettype = \"uint32x4_t\", argtypes = \"[uint8x16_t]\", vals = [VectorVal [IntegerVal 0,IntegerVal 0,IntegerVal 255,IntegerVal 128,IntegerVal 127,IntegerVal 223,IntegerVal 0,IntegerVal 128,IntegerVal 0,IntegerVal 128,IntegerVal 128,IntegerVal 0,IntegerVal 128,IntegerVal 128,IntegerVal 127,IntegerVal 255]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u8(vcreate_u8(UINT64_C(0x8000df7f80ff0000)),
                         vcreate_u8(UINT64_C(0xff7f808000808000)));
      clear_neon_saturated();
      //  Expect: "result" = ff7f8080008080008000df7f80ff0000
      result = vreinterpretq_u32_u8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 0);
         exp = UINT64_C(0x8000df7f80ff0000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 1);
         exp = UINT64_C(0xff7f808000808000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2896() {

{
   {
      uint8x16_t arg1;
      poly8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpretq_p8_u8\", rettype = \"poly8x16_t\", argtypes = \"[uint8x16_t]\", vals = [VectorVal [IntegerVal 127,IntegerVal 255,IntegerVal 255,IntegerVal 128,IntegerVal 255,IntegerVal 128,IntegerVal 0,IntegerVal 255,IntegerVal 127,IntegerVal 0,IntegerVal 127,IntegerVal 0,IntegerVal 127,IntegerVal 176,IntegerVal 0,IntegerVal 0]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u8(vcreate_u8(UINT64_C(0xff0080ff80ffff7f)),
                         vcreate_u8(UINT64_C(0x0000b07f007f007f)));
      clear_neon_saturated();
      //  Expect: "result" = 0000b07f007f007fff0080ff80ffff7f
      result = vreinterpretq_p8_u8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p8(result), 0);
         exp = UINT64_C(0xff0080ff80ffff7f);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p8(result), 1);
         exp = UINT64_C(0x0000b07f007f007f);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2897() {

{
   {
      uint8x16_t arg1;
      poly16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpretq_p16_u8\", rettype = \"poly16x8_t\", argtypes = \"[uint8x16_t]\", vals = [VectorVal [IntegerVal 48,IntegerVal 127,IntegerVal 128,IntegerVal 127,IntegerVal 127,IntegerVal 255,IntegerVal 125,IntegerVal 127,IntegerVal 128,IntegerVal 128,IntegerVal 127,IntegerVal 127,IntegerVal 176,IntegerVal 129,IntegerVal 127,IntegerVal 255]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u8(vcreate_u8(UINT64_C(0x7f7dff7f7f807f30)),
                         vcreate_u8(UINT64_C(0xff7f81b07f7f8080)));
      clear_neon_saturated();
      //  Expect: "result" = ff7f81b07f7f80807f7dff7f7f807f30
      result = vreinterpretq_p16_u8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p16(result), 0);
         exp = UINT64_C(0x7f7dff7f7f807f30);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p16(result), 1);
         exp = UINT64_C(0xff7f81b07f7f8080);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2898() {

{
   {
      uint8x16_t arg1;
      uint64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpretq_u64_u8\", rettype = \"uint64x2_t\", argtypes = \"[uint8x16_t]\", vals = [VectorVal [IntegerVal 128,IntegerVal 128,IntegerVal 114,IntegerVal 0,IntegerVal 127,IntegerVal 127,IntegerVal 235,IntegerVal 127,IntegerVal 0,IntegerVal 0,IntegerVal 27,IntegerVal 128,IntegerVal 122,IntegerVal 128,IntegerVal 127,IntegerVal 128]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u8(vcreate_u8(UINT64_C(0x7feb7f7f00728080)),
                         vcreate_u8(UINT64_C(0x807f807a801b0000)));
      clear_neon_saturated();
      //  Expect: "result" = 807f807a801b00007feb7f7f00728080
      result = vreinterpretq_u64_u8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 0);
         exp = UINT64_C(0x7feb7f7f00728080);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 1);
         exp = UINT64_C(0x807f807a801b0000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2899() {

{
   {
      uint8x16_t arg1;
      int64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpretq_s64_u8\", rettype = \"int64x2_t\", argtypes = \"[uint8x16_t]\", vals = [VectorVal [IntegerVal 19,IntegerVal 255,IntegerVal 255,IntegerVal 0,IntegerVal 255,IntegerVal 255,IntegerVal 0,IntegerVal 127,IntegerVal 127,IntegerVal 128,IntegerVal 117,IntegerVal 0,IntegerVal 128,IntegerVal 127,IntegerVal 255,IntegerVal 128]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u8(vcreate_u8(UINT64_C(0x7f00ffff00ffff13)),
                         vcreate_u8(UINT64_C(0x80ff7f800075807f)));
      clear_neon_saturated();
      //  Expect: "result" = 80ff7f800075807f7f00ffff00ffff13
      result = vreinterpretq_s64_u8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 0);
         exp = UINT64_C(0x7f00ffff00ffff13);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 1);
         exp = UINT64_C(0x80ff7f800075807f);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2900() {
#if __ARM_NEON_FP16_INTRINSICS

{
   {
      uint8x16_t arg1;
      float16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpretq_f16_u8\", rettype = \"float16x8_t\", argtypes = \"[uint8x16_t]\", vals = [VectorVal [IntegerVal 38,IntegerVal 85,IntegerVal 104,IntegerVal 63,IntegerVal 73,IntegerVal 20,IntegerVal 21,IntegerVal 63,IntegerVal 60,IntegerVal 135,IntegerVal 183,IntegerVal 62,IntegerVal 184,IntegerVal 106,IntegerVal 185,IntegerVal 61]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u8(vcreate_u8(UINT64_C(0x3f1514493f685526)),
                         vcreate_u8(UINT64_C(0x3db96ab83eb7873c)));
      clear_neon_saturated();
      //  Expect: "result" = 3db96ab83eb7873c3f1514493f685526
      result = vreinterpretq_f16_u8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result, 0);
         exp = 82.375;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result, 1);
         exp = 1.8515625;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result, 2);
         exp = 1.0461807250976563e-3;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 2 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result, 3);
         exp = 1.7705078125;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 3 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result, 4);
         exp = -1.1038780212402344e-4;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 4 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result, 5);
         exp = 1.6787109375;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 5 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result, 6);
         exp = 3440.0;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 6 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result, 7);
         exp = 1.4306640625;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 7 ", exp, got);
            }
      }
   }
}
#endif
}
void dotests_2901() {

{
   {
      uint16x8_t arg1;
      int8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpretq_s8_u16\", rettype = \"int8x16_t\", argtypes = \"[uint16x8_t]\", vals = [VectorVal [IntegerVal 26705,IntegerVal 32768,IntegerVal 0,IntegerVal 32767,IntegerVal 19075,IntegerVal 65535,IntegerVal 32767,IntegerVal 32768]], start_saturated = True}";
      int reported = 0;
      arg1 = vcombine_u16(vcreate_u16(UINT64_C(0x7fff000080006851)),
                          vcreate_u16(UINT64_C(0x80007fffffff4a83)));
      set_neon_saturated();
      //  Expect: "result" = 80007fffffff4a837fff000080006851
      result = vreinterpretq_s8_u16(arg1);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result), 0);
         exp = UINT64_C(0x7fff000080006851);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result), 1);
         exp = UINT64_C(0x80007fffffff4a83);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2902() {

{
   {
      uint16x8_t arg1;
      int16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpretq_s16_u16\", rettype = \"int16x8_t\", argtypes = \"[uint16x8_t]\", vals = [VectorVal [IntegerVal 0,IntegerVal 32767,IntegerVal 60023,IntegerVal 32768,IntegerVal 0,IntegerVal 0,IntegerVal 65535,IntegerVal 0]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u16(vcreate_u16(UINT64_C(0x8000ea777fff0000)),
                          vcreate_u16(UINT64_C(0x0000ffff00000000)));
      clear_neon_saturated();
      //  Expect: "result" = 0000ffff000000008000ea777fff0000
      result = vreinterpretq_s16_u16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 0);
         exp = UINT64_C(0x8000ea777fff0000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 1);
         exp = UINT64_C(0x0000ffff00000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2903() {

{
   {
      uint16x8_t arg1;
      int32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpretq_s32_u16\", rettype = \"int32x4_t\", argtypes = \"[uint16x8_t]\", vals = [VectorVal [IntegerVal 0,IntegerVal 65535,IntegerVal 32767,IntegerVal 44491,IntegerVal 32767,IntegerVal 65535,IntegerVal 65535,IntegerVal 14365]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u16(vcreate_u16(UINT64_C(0xadcb7fffffff0000)),
                          vcreate_u16(UINT64_C(0x381dffffffff7fff)));
      clear_neon_saturated();
      //  Expect: "result" = 381dffffffff7fffadcb7fffffff0000
      result = vreinterpretq_s32_u16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 0);
         exp = UINT64_C(0xadcb7fffffff0000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 1);
         exp = UINT64_C(0x381dffffffff7fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2904() {

{
   {
      uint16x8_t arg1;
      float32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpretq_f32_u16\", rettype = \"float32x4_t\", argtypes = \"[uint16x8_t]\", vals = [VectorVal [IntegerVal 775,IntegerVal 16219,IntegerVal 2350,IntegerVal 16097,IntegerVal 25796,IntegerVal 16201,IntegerVal 18042,IntegerVal 16006]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u16(vcreate_u16(UINT64_C(0x3ee1092e3f5b0307)),
                          vcreate_u16(UINT64_C(0x3e86467a3f4964c4)));
      clear_neon_saturated();
      //  Expect: "result" = 3e86467a3f4964c43ee1092e3f5b0307
      result = vreinterpretq_f32_u16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 0);
         exp = ((float32_t) 0.8555149435997009);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 1);
         exp = ((float32_t) 0.4395231604576111);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 2);
         exp = ((float32_t) 0.786693811416626);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 2 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 3);
         exp = ((float32_t) 0.2622564435005188);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 3 ", exp, got);
            }
      }
   }
}
}
void dotests_2905() {

{
   {
      uint16x8_t arg1;
      uint8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpretq_u8_u16\", rettype = \"uint8x16_t\", argtypes = \"[uint16x8_t]\", vals = [VectorVal [IntegerVal 0,IntegerVal 50562,IntegerVal 32767,IntegerVal 32768,IntegerVal 32767,IntegerVal 19023,IntegerVal 21402,IntegerVal 0]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u16(vcreate_u16(UINT64_C(0x80007fffc5820000)),
                          vcreate_u16(UINT64_C(0x0000539a4a4f7fff)));
      clear_neon_saturated();
      //  Expect: "result" = 0000539a4a4f7fff80007fffc5820000
      result = vreinterpretq_u8_u16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 0);
         exp = UINT64_C(0x80007fffc5820000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 1);
         exp = UINT64_C(0x0000539a4a4f7fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2906() {

{
   {
      uint16x8_t arg1;
      uint32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpretq_u32_u16\", rettype = \"uint32x4_t\", argtypes = \"[uint16x8_t]\", vals = [VectorVal [IntegerVal 0,IntegerVal 0,IntegerVal 0,IntegerVal 0,IntegerVal 32767,IntegerVal 19191,IntegerVal 32767,IntegerVal 0]], start_saturated = True}";
      int reported = 0;
      arg1 = vcombine_u16(vcreate_u16(0),
                          vcreate_u16(UINT64_C(0x00007fff4af77fff)));
      set_neon_saturated();
      //  Expect: "result" = 00007fff4af77fff0000000000000000
      result = vreinterpretq_u32_u16(arg1);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 0);
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 1);
         exp = UINT64_C(0x00007fff4af77fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2907() {

{
   {
      uint16x8_t arg1;
      poly8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpretq_p8_u16\", rettype = \"poly8x16_t\", argtypes = \"[uint16x8_t]\", vals = [VectorVal [IntegerVal 32767,IntegerVal 32767,IntegerVal 32768,IntegerVal 32768,IntegerVal 65535,IntegerVal 43067,IntegerVal 32768,IntegerVal 64509]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u16(vcreate_u16(UINT64_C(0x800080007fff7fff)),
                          vcreate_u16(UINT64_C(0xfbfd8000a83bffff)));
      clear_neon_saturated();
      //  Expect: "result" = fbfd8000a83bffff800080007fff7fff
      result = vreinterpretq_p8_u16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p8(result), 0);
         exp = UINT64_C(0x800080007fff7fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p8(result), 1);
         exp = UINT64_C(0xfbfd8000a83bffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2908() {

{
   {
      uint16x8_t arg1;
      poly16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpretq_p16_u16\", rettype = \"poly16x8_t\", argtypes = \"[uint16x8_t]\", vals = [VectorVal [IntegerVal 65535,IntegerVal 31020,IntegerVal 32768,IntegerVal 0,IntegerVal 0,IntegerVal 32768,IntegerVal 65535,IntegerVal 0]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u16(vcreate_u16(UINT64_C(0x00008000792cffff)),
                          vcreate_u16(UINT64_C(0x0000ffff80000000)));
      clear_neon_saturated();
      //  Expect: "result" = 0000ffff8000000000008000792cffff
      result = vreinterpretq_p16_u16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p16(result), 0);
         exp = UINT64_C(0x00008000792cffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p16(result), 1);
         exp = UINT64_C(0x0000ffff80000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2909() {

{
   {
      uint16x8_t arg1;
      uint64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpretq_u64_u16\", rettype = \"uint64x2_t\", argtypes = \"[uint16x8_t]\", vals = [VectorVal [IntegerVal 32768,IntegerVal 32768,IntegerVal 32768,IntegerVal 32768,IntegerVal 65535,IntegerVal 32768,IntegerVal 32767,IntegerVal 32767]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u16(vcreate_u16(UINT64_C(0x8000800080008000)),
                          vcreate_u16(UINT64_C(0x7fff7fff8000ffff)));
      clear_neon_saturated();
      //  Expect: "result" = 7fff7fff8000ffff8000800080008000
      result = vreinterpretq_u64_u16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 0);
         exp = UINT64_C(0x8000800080008000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 1);
         exp = UINT64_C(0x7fff7fff8000ffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2910() {

{
   {
      uint16x8_t arg1;
      int64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpretq_s64_u16\", rettype = \"int64x2_t\", argtypes = \"[uint16x8_t]\", vals = [VectorVal [IntegerVal 0,IntegerVal 0,IntegerVal 0,IntegerVal 32768,IntegerVal 36144,IntegerVal 25277,IntegerVal 32767,IntegerVal 65535]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u16(vcreate_u16(UINT64_C(0x8000000000000000)),
                          vcreate_u16(UINT64_C(0xffff7fff62bd8d30)));
      clear_neon_saturated();
      //  Expect: "result" = ffff7fff62bd8d308000000000000000
      result = vreinterpretq_s64_u16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 0);
         exp = UINT64_C(0x8000000000000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 1);
         exp = UINT64_C(0xffff7fff62bd8d30);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2911() {
#if __ARM_NEON_FP16_INTRINSICS

{
   {
      uint16x8_t arg1;
      float16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpretq_f16_u16\", rettype = \"float16x8_t\", argtypes = \"[uint16x8_t]\", vals = [VectorVal [IntegerVal 45562,IntegerVal 16205,IntegerVal 37850,IntegerVal 16108,IntegerVal 61128,IntegerVal 15908,IntegerVal 52218,IntegerVal 16113]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u16(vcreate_u16(UINT64_C(0x3eec93da3f4db1fa)),
                          vcreate_u16(UINT64_C(0x3ef1cbfa3e24eec8)));
      clear_neon_saturated();
      //  Expect: "result" = 3ef1cbfa3e24eec83eec93da3f4db1fa
      result = vreinterpretq_f16_u16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result, 0);
         exp = -0.186767578125;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result, 1);
         exp = 1.8251953125;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result, 2);
         exp = -9.584426879882813e-4;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 2 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result, 3);
         exp = 1.73046875;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 3 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result, 4);
         exp = -6944.0;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 4 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result, 5);
         exp = 1.53515625;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 5 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result, 6);
         exp = -15.953125;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 6 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result, 7);
         exp = 1.7353515625;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 7 ", exp, got);
            }
      }
   }
}
#endif
}
void dotests_2912() {

{
   {
      uint32x4_t arg1;
      int8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpretq_s8_u32\", rettype = \"int8x16_t\", argtypes = \"[uint32x4_t]\", vals = [VectorVal [IntegerVal 2147516416,IntegerVal 2147418112,IntegerVal 2147549183,IntegerVal 2147450880]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u32(vcreate_u32(UINT64_C(0x7fff000080008000)),
                          vcreate_u32(UINT64_C(0x7fff80008000ffff)));
      clear_neon_saturated();
      //  Expect: "result" = 7fff80008000ffff7fff000080008000
      result = vreinterpretq_s8_u32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result), 0);
         exp = UINT64_C(0x7fff000080008000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result), 1);
         exp = UINT64_C(0x7fff80008000ffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2913() {

{
   {
      uint32x4_t arg1;
      int16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpretq_s16_u32\", rettype = \"int16x8_t\", argtypes = \"[uint32x4_t]\", vals = [VectorVal [IntegerVal 2147458358,IntegerVal 1252603292,IntegerVal 32767,IntegerVal 32768]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u32(vcreate_u32(UINT64_C(0x4aa9359c7fff9d36)),
                          vcreate_u32(UINT64_C(0x0000800000007fff)));
      clear_neon_saturated();
      //  Expect: "result" = 0000800000007fff4aa9359c7fff9d36
      result = vreinterpretq_s16_u32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 0);
         exp = UINT64_C(0x4aa9359c7fff9d36);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 1);
         exp = UINT64_C(0x0000800000007fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2914() {

{
   {
      uint32x4_t arg1;
      int32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpretq_s32_u32\", rettype = \"int32x4_t\", argtypes = \"[uint32x4_t]\", vals = [VectorVal [IntegerVal 32767,IntegerVal 2147514446,IntegerVal 754221056,IntegerVal 2147483648]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u32(vcreate_u32(UINT64_C(0x8000784e00007fff)),
                          vcreate_u32(UINT64_C(0x800000002cf48000)));
      clear_neon_saturated();
      //  Expect: "result" = 800000002cf480008000784e00007fff
      result = vreinterpretq_s32_u32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 0);
         exp = UINT64_C(0x8000784e00007fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 1);
         exp = UINT64_C(0x800000002cf48000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2915() {

{
   {
      uint32x4_t arg1;
      float32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpretq_f32_u32\", rettype = \"float32x4_t\", argtypes = \"[uint32x4_t]\", vals = [VectorVal [IntegerVal 1032978416,IntegerVal 1061052235,IntegerVal 1048945864,IntegerVal 1059283308]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u32(vcreate_u32(UINT64_C(0x3f3e5f4b3d91fff0)),
                          vcreate_u32(UINT64_C(0x3f23616c3e85a4c8)));
      clear_neon_saturated();
      //  Expect: "result" = 3f23616c3e85a4c83f3e5f4b3d91fff0
      result = vreinterpretq_f32_u32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 0);
         exp = ((float32_t) 7.128894329071045e-2);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 1);
         exp = ((float32_t) 0.7436415553092957);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 2);
         exp = ((float32_t) 0.26102280616760254);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 2 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 3);
         exp = ((float32_t) 0.6382052898406982);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 3 ", exp, got);
            }
      }
   }
}
}
void dotests_2916() {

{
   {
      uint32x4_t arg1;
      uint8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpretq_u8_u32\", rettype = \"uint8x16_t\", argtypes = \"[uint32x4_t]\", vals = [VectorVal [IntegerVal 4294924475,IntegerVal 2147450880,IntegerVal 32767,IntegerVal 2147516416]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u32(vcreate_u32(UINT64_C(0x7fff8000ffff58bb)),
                          vcreate_u32(UINT64_C(0x8000800000007fff)));
      clear_neon_saturated();
      //  Expect: "result" = 8000800000007fff7fff8000ffff58bb
      result = vreinterpretq_u8_u32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 0);
         exp = UINT64_C(0x7fff8000ffff58bb);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 1);
         exp = UINT64_C(0x8000800000007fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2917() {

{
   {
      uint32x4_t arg1;
      uint16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpretq_u16_u32\", rettype = \"uint16x8_t\", argtypes = \"[uint32x4_t]\", vals = [VectorVal [IntegerVal 32767,IntegerVal 4294967295,IntegerVal 2147483648,IntegerVal 535658495]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u32(vcreate_u32(UINT64_C(0xffffffff00007fff)),
                          vcreate_u32(UINT64_C(0x1fed7fff80000000)));
      clear_neon_saturated();
      //  Expect: "result" = 1fed7fff80000000ffffffff00007fff
      result = vreinterpretq_u16_u32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 0);
         exp = UINT64_C(0xffffffff00007fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 1);
         exp = UINT64_C(0x1fed7fff80000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2918() {

{
   {
      uint32x4_t arg1;
      poly8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpretq_p8_u32\", rettype = \"poly8x16_t\", argtypes = \"[uint32x4_t]\", vals = [VectorVal [IntegerVal 4294901760,IntegerVal 2147418112,IntegerVal 32767,IntegerVal 2147516415]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u32(vcreate_u32(UINT64_C(0x7fff0000ffff0000)),
                          vcreate_u32(UINT64_C(0x80007fff00007fff)));
      clear_neon_saturated();
      //  Expect: "result" = 80007fff00007fff7fff0000ffff0000
      result = vreinterpretq_p8_u32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p8(result), 0);
         exp = UINT64_C(0x7fff0000ffff0000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p8(result), 1);
         exp = UINT64_C(0x80007fff00007fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2919() {

{
   {
      uint32x4_t arg1;
      poly16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpretq_p16_u32\", rettype = \"poly16x8_t\", argtypes = \"[uint32x4_t]\", vals = [VectorVal [IntegerVal 4170776576,IntegerVal 2147450880,IntegerVal 4294967295,IntegerVal 65535]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u32(vcreate_u32(UINT64_C(0x7fff8000f8990000)),
                          vcreate_u32(UINT64_C(0x0000ffffffffffff)));
      clear_neon_saturated();
      //  Expect: "result" = 0000ffffffffffff7fff8000f8990000
      result = vreinterpretq_p16_u32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p16(result), 0);
         exp = UINT64_C(0x7fff8000f8990000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p16(result), 1);
         exp = UINT64_C(0x0000ffffffffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2920() {

{
   {
      uint32x4_t arg1;
      uint64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpretq_u64_u32\", rettype = \"uint64x2_t\", argtypes = \"[uint32x4_t]\", vals = [VectorVal [IntegerVal 48964,IntegerVal 4294943661,IntegerVal 2147516416,IntegerVal 4294934528]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u32(vcreate_u32(UINT64_C(0xffffa3ad0000bf44)),
                          vcreate_u32(UINT64_C(0xffff800080008000)));
      clear_neon_saturated();
      //  Expect: "result" = ffff800080008000ffffa3ad0000bf44
      result = vreinterpretq_u64_u32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 0);
         exp = UINT64_C(0xffffa3ad0000bf44);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 1);
         exp = UINT64_C(0xffff800080008000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2921() {

{
   {
      uint32x4_t arg1;
      int64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpretq_s64_u32\", rettype = \"int64x2_t\", argtypes = \"[uint32x4_t]\", vals = [VectorVal [IntegerVal 4294934528,IntegerVal 4294958268,IntegerVal 2147516416,IntegerVal 4294901760]], start_saturated = True}";
      int reported = 0;
      arg1 = vcombine_u32(vcreate_u32(UINT64_C(0xffffdcbcffff8000)),
                          vcreate_u32(UINT64_C(0xffff000080008000)));
      set_neon_saturated();
      //  Expect: "result" = ffff000080008000ffffdcbcffff8000
      result = vreinterpretq_s64_u32(arg1);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 0);
         exp = UINT64_C(0xffffdcbcffff8000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 1);
         exp = UINT64_C(0xffff000080008000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2922() {
#if __ARM_NEON_FP16_INTRINSICS

{
   {
      uint32x4_t arg1;
      float16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpretq_f16_u32\", rettype = \"float16x8_t\", argtypes = \"[uint32x4_t]\", vals = [VectorVal [IntegerVal 1050484592,IntegerVal 1063637054,IntegerVal 1049780160,IntegerVal 1063432236]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u32(vcreate_u32(UINT64_C(0x3f65d03e3e9d1f70)),
                          vcreate_u32(UINT64_C(0x3f62b02c3e925fc0)));
      clear_neon_saturated();
      //  Expect: "result" = 3f62b02c3e925fc03f65d03e3e9d1f70
      result = vreinterpretq_f16_u32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result, 0);
         exp = 7.26318359375e-3;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result, 1);
         exp = 1.6533203125;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result, 2);
         exp = -33.9375;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 2 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result, 3);
         exp = 1.8486328125;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 3 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result, 4);
         exp = 496.0;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 4 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result, 5);
         exp = 1.642578125;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 5 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result, 6);
         exp = -0.13037109375;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 6 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result, 7);
         exp = 1.845703125;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 7 ", exp, got);
            }
      }
   }
}
#endif
}
void dotests_2923() {

{
   {
      poly8x16_t arg1;
      int8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpretq_s8_p8\", rettype = \"int8x16_t\", argtypes = \"[poly8x16_t]\", vals = [VectorVal [PolyVal [1,0,0,1,1,1,0,1],PolyVal [0,0,0,1,0,1,1,0],PolyVal [0,1,1,1,0,0,1,0],PolyVal [1,1,1,1,1,0,1,1],PolyVal [1,1,1,1,1,0,1,1],PolyVal [1,1,1,0,1,0,0,0],PolyVal [0,1,0,1,1,0,1,1],PolyVal [0,1,1,1,0,1,0,0],PolyVal [1,0,1,0,1,1,1,1],PolyVal [1,1,0,1,0,0,1,1],PolyVal [0,0,1,0,1,1,0,0],PolyVal [0,0,1,1,1,0,1,0],PolyVal [0,0,1,1,1,1,1,1],PolyVal [1,1,0,0,0,1,0,1],PolyVal [1,1,0,1,1,1,0,1],PolyVal [1,1,0,0,0,1,1,1]]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_p8(vcreate_p8(UINT64_C(0x2eda17dfdf4e68b9)),
                         vcreate_p8(UINT64_C(0xe3bba3fc5c34cbf5)));
      clear_neon_saturated();
      //  Expect: "result" = e3bba3fc5c34cbf52eda17dfdf4e68b9
      result = vreinterpretq_s8_p8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result), 0);
         exp = UINT64_C(0x2eda17dfdf4e68b9);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result), 1);
         exp = UINT64_C(0xe3bba3fc5c34cbf5);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2924() {

{
   {
      poly8x16_t arg1;
      int16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpretq_s16_p8\", rettype = \"int16x8_t\", argtypes = \"[poly8x16_t]\", vals = [VectorVal [PolyVal [0,1,0,1,1,1,0,1],PolyVal [0,0,0,1,1,0,1,1],PolyVal [0,1,1,1,1,0,0,1],PolyVal [0,1,1,1,1,0,0,1],PolyVal [0,0,0,0,0,1,0,0],PolyVal [1,1,1,0,0,1,1,0],PolyVal [1,1,0,1,0,0,1,1],PolyVal [1,0,0,0,0,1,1,1],PolyVal [1,0,0,0,0,1,1,0],PolyVal [0,0,1,0,0,0,0,0],PolyVal [1,0,0,1,1,0,0,1],PolyVal [1,1,1,0,0,1,1,0],PolyVal [1,0,1,1,1,1,1,1],PolyVal [0,0,1,1,0,1,1,1],PolyVal [0,1,0,0,0,0,1,1],PolyVal [0,0,1,0,1,0,0,0]]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_p8(vcreate_p8(UINT64_C(0xe1cb67209e9ed8ba)),
                         vcreate_p8(UINT64_C(0x14c2ecfd67990461)));
      clear_neon_saturated();
      //  Expect: "result" = 14c2ecfd67990461e1cb67209e9ed8ba
      result = vreinterpretq_s16_p8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 0);
         exp = UINT64_C(0xe1cb67209e9ed8ba);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 1);
         exp = UINT64_C(0x14c2ecfd67990461);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2925() {

{
   {
      poly8x16_t arg1;
      int32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpretq_s32_p8\", rettype = \"int32x4_t\", argtypes = \"[poly8x16_t]\", vals = [VectorVal [PolyVal [0,1,0,0,0,1,0,0],PolyVal [0,0,1,1,1,1,0,1],PolyVal [1,1,1,0,0,0,1,1],PolyVal [1,0,0,1,1,0,0,1],PolyVal [1,1,0,1,0,1,1,1],PolyVal [1,0,0,1,1,0,0,0],PolyVal [0,1,1,0,0,0,0,0],PolyVal [0,0,0,0,0,1,1,1],PolyVal [0,0,1,1,1,1,0,0],PolyVal [1,1,1,1,0,1,0,1],PolyVal [0,1,0,0,1,0,1,0],PolyVal [1,1,1,1,1,0,0,0],PolyVal [1,1,0,1,0,1,1,0],PolyVal [1,0,0,1,0,0,1,1],PolyVal [1,1,1,0,1,1,0,0],PolyVal [1,0,1,0,0,1,0,0]]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_p8(vcreate_p8(UINT64_C(0xe00619eb99c7bc22)),
                         vcreate_p8(UINT64_C(0x2537c96b1f52af3c)));
      clear_neon_saturated();
      //  Expect: "result" = 2537c96b1f52af3ce00619eb99c7bc22
      result = vreinterpretq_s32_p8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 0);
         exp = UINT64_C(0xe00619eb99c7bc22);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 1);
         exp = UINT64_C(0x2537c96b1f52af3c);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2926() {

{
   {
      poly8x16_t arg1;
      float32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpretq_f32_p8\", rettype = \"float32x4_t\", argtypes = \"[poly8x16_t]\", vals = [VectorVal [PolyVal [0,0,1,1,1,1,1,0],PolyVal [0,0,0,0,1,1,1,0],PolyVal [0,0,1,0,1,0,1,0],PolyVal [1,1,1,1,1,1,0,0],PolyVal [0,1,0,1,1,1,1,0],PolyVal [0,1,1,0,0,0,1,1],PolyVal [0,1,1,0,1,1,0,0],PolyVal [1,1,1,1,1,1,0,0],PolyVal [0,0,1,0,0,1,1,0],PolyVal [0,1,1,0,1,0,1,1],PolyVal [0,1,1,0,1,0,0,0],PolyVal [1,1,1,1,1,1,0,0],PolyVal [1,1,1,1,1,0,0,1],PolyVal [1,0,0,1,0,1,1,1],PolyVal [1,0,0,0,1,0,0,0],PolyVal [1,1,1,1,1,1,0,0]]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_p8(vcreate_p8(UINT64_C(0x3f36c67a3f54707c)),
                         vcreate_p8(UINT64_C(0x3f11e99f3f16d664)));
      clear_neon_saturated();
      //  Expect: "result" = 3f11e99f3f16d6643f36c67a3f54707c
      result = vreinterpretq_f32_p8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 0);
         exp = ((float32_t) 0.8298413753509521);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 1);
         exp = ((float32_t) 0.7139660120010376);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 2);
         exp = ((float32_t) 0.5892088413238525);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 2 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 3);
         exp = ((float32_t) 0.5699710249900818);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 3 ", exp, got);
            }
      }
   }
}
}
void dotests_2927() {

{
   {
      poly8x16_t arg1;
      uint8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpretq_u8_p8\", rettype = \"uint8x16_t\", argtypes = \"[poly8x16_t]\", vals = [VectorVal [PolyVal [1,1,1,1,1,1,1,0],PolyVal [1,0,1,0,0,0,1,0],PolyVal [0,0,0,1,1,1,0,0],PolyVal [1,0,0,0,1,0,1,1],PolyVal [0,0,0,0,0,0,0,1],PolyVal [0,1,0,1,0,1,1,1],PolyVal [0,1,1,0,1,0,1,0],PolyVal [1,1,1,0,1,0,0,0],PolyVal [1,0,1,1,0,0,1,0],PolyVal [0,0,1,0,1,1,0,1],PolyVal [0,0,0,1,1,1,1,1],PolyVal [1,1,1,0,0,1,0,1],PolyVal [1,0,0,0,0,0,0,0],PolyVal [0,0,0,1,1,0,1,1],PolyVal [1,0,0,0,1,1,1,1],PolyVal [1,1,1,0,0,0,1,0]]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_p8(vcreate_p8(UINT64_C(0x1756ea80d138457f)),
                         vcreate_p8(UINT64_C(0x47f1d801a7f8b44d)));
      clear_neon_saturated();
      //  Expect: "result" = 47f1d801a7f8b44d1756ea80d138457f
      result = vreinterpretq_u8_p8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 0);
         exp = UINT64_C(0x1756ea80d138457f);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 1);
         exp = UINT64_C(0x47f1d801a7f8b44d);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2928() {

{
   {
      poly8x16_t arg1;
      uint16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpretq_u16_p8\", rettype = \"uint16x8_t\", argtypes = \"[poly8x16_t]\", vals = [VectorVal [PolyVal [0,1,1,0,0,0,0,1],PolyVal [1,1,0,1,0,1,0,1],PolyVal [0,0,0,1,1,0,1,1],PolyVal [0,1,1,0,0,1,0,0],PolyVal [0,0,0,0,0,1,0,1],PolyVal [0,0,0,1,1,0,1,1],PolyVal [1,1,1,0,1,0,1,0],PolyVal [1,0,0,0,0,1,0,0],PolyVal [1,0,1,1,0,1,1,1],PolyVal [0,1,0,0,0,0,0,0],PolyVal [1,1,0,1,0,0,1,1],PolyVal [1,0,1,1,0,0,0,0],PolyVal [1,1,0,0,0,1,1,0],PolyVal [0,1,1,0,0,0,0,1],PolyVal [1,0,0,0,0,0,0,1],PolyVal [0,1,0,1,0,1,1,1]]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_p8(vcreate_p8(UINT64_C(0x2157d8a026d8ab86)),
                         vcreate_p8(UINT64_C(0xea8186630dcb02ed)));
      clear_neon_saturated();
      //  Expect: "result" = ea8186630dcb02ed2157d8a026d8ab86
      result = vreinterpretq_u16_p8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 0);
         exp = UINT64_C(0x2157d8a026d8ab86);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 1);
         exp = UINT64_C(0xea8186630dcb02ed);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2929() {

{
   {
      poly8x16_t arg1;
      uint32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpretq_u32_p8\", rettype = \"uint32x4_t\", argtypes = \"[poly8x16_t]\", vals = [VectorVal [PolyVal [0,0,1,0,0,1,0,1],PolyVal [1,0,1,1,1,1,0,1],PolyVal [1,0,1,1,0,1,0,0],PolyVal [0,0,1,0,0,0,0,1],PolyVal [0,0,0,0,0,0,0,1],PolyVal [1,1,0,0,0,0,0,1],PolyVal [0,1,0,1,0,1,0,0],PolyVal [0,0,1,0,1,0,0,0],PolyVal [0,0,0,1,0,1,1,0],PolyVal [0,1,0,0,1,0,0,1],PolyVal [1,0,0,1,0,1,1,1],PolyVal [0,0,1,0,0,0,1,0],PolyVal [0,1,1,0,1,1,0,0],PolyVal [0,0,0,1,0,0,0,1],PolyVal [1,0,1,0,1,0,0,0],PolyVal [1,0,0,0,0,1,0,1]]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_p8(vcreate_p8(UINT64_C(0x142a8380842dbda4)),
                         vcreate_p8(UINT64_C(0xa115883644e99268)));
      clear_neon_saturated();
      //  Expect: "result" = a115883644e99268142a8380842dbda4
      result = vreinterpretq_u32_p8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 0);
         exp = UINT64_C(0x142a8380842dbda4);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 1);
         exp = UINT64_C(0xa115883644e99268);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2930() {

{
   {
      poly8x16_t arg1;
      poly16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpretq_p16_p8\", rettype = \"poly16x8_t\", argtypes = \"[poly8x16_t]\", vals = [VectorVal [PolyVal [0,1,1,0,1,1,0,0],PolyVal [0,0,0,1,1,0,1,1],PolyVal [0,0,1,1,0,1,1,1],PolyVal [1,1,0,1,0,0,1,0],PolyVal [1,0,1,1,0,0,0,1],PolyVal [1,1,1,1,1,1,1,1],PolyVal [0,1,0,1,0,0,0,1],PolyVal [1,0,0,0,1,1,0,0],PolyVal [0,0,1,0,1,1,1,1],PolyVal [0,0,1,1,1,0,0,1],PolyVal [1,0,1,1,1,1,0,0],PolyVal [1,0,0,1,0,0,1,1],PolyVal [1,0,1,0,0,0,0,1],PolyVal [1,0,0,0,0,1,0,1],PolyVal [0,1,1,1,0,1,0,1],PolyVal [1,0,1,1,1,1,0,0]]], start_saturated = True}";
      int reported = 0;
      arg1 = vcombine_p8(vcreate_p8(UINT64_C(0x318aff8d4becd836)),
                         vcreate_p8(UINT64_C(0x3daea185c93d9cf4)));
      set_neon_saturated();
      //  Expect: "result" = 3daea185c93d9cf4318aff8d4becd836
      result = vreinterpretq_p16_p8(arg1);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p16(result), 0);
         exp = UINT64_C(0x318aff8d4becd836);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p16(result), 1);
         exp = UINT64_C(0x3daea185c93d9cf4);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2931() {

{
   {
      poly8x16_t arg1;
      uint64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpretq_u64_p8\", rettype = \"uint64x2_t\", argtypes = \"[poly8x16_t]\", vals = [VectorVal [PolyVal [0,0,1,0,0,0,0,1],PolyVal [1,0,1,0,0,0,0,1],PolyVal [0,1,1,1,1,1,1,0],PolyVal [1,1,0,1,0,1,0,0],PolyVal [0,1,0,0,1,0,0,1],PolyVal [1,1,0,0,1,0,1,1],PolyVal [1,1,1,0,0,0,1,1],PolyVal [1,1,0,1,0,0,0,1],PolyVal [1,0,1,0,0,0,1,1],PolyVal [1,1,1,1,0,1,1,1],PolyVal [0,0,0,0,0,1,1,1],PolyVal [1,0,1,1,0,1,1,0],PolyVal [1,0,0,0,0,0,1,0],PolyVal [0,1,0,0,0,0,1,1],PolyVal [0,1,1,0,1,0,0,1],PolyVal [0,0,1,1,0,0,1,0]]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_p8(vcreate_p8(UINT64_C(0x8bc7d3922b7e8584)),
                         vcreate_p8(UINT64_C(0x4c96c2416de0efc5)));
      clear_neon_saturated();
      //  Expect: "result" = 4c96c2416de0efc58bc7d3922b7e8584
      result = vreinterpretq_u64_p8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 0);
         exp = UINT64_C(0x8bc7d3922b7e8584);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 1);
         exp = UINT64_C(0x4c96c2416de0efc5);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2932() {

{
   {
      poly8x16_t arg1;
      int64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpretq_s64_p8\", rettype = \"int64x2_t\", argtypes = \"[poly8x16_t]\", vals = [VectorVal [PolyVal [0,0,0,0,0,1,1,0],PolyVal [0,1,0,1,0,1,1,0],PolyVal [0,1,1,0,0,0,1,0],PolyVal [1,0,1,0,0,0,1,0],PolyVal [1,0,1,0,0,1,0,1],PolyVal [1,0,0,0,1,1,0,0],PolyVal [0,0,0,0,1,1,1,1],PolyVal [0,0,0,0,1,0,0,0],PolyVal [1,1,1,1,1,0,1,0],PolyVal [1,0,0,0,1,0,0,0],PolyVal [1,0,0,0,0,0,0,1],PolyVal [1,1,1,0,1,0,1,0],PolyVal [0,0,1,1,1,1,1,0],PolyVal [0,0,1,0,0,1,1,1],PolyVal [0,1,0,1,0,0,0,0],PolyVal [1,0,0,1,0,1,1,0]]], start_saturated = True}";
      int reported = 0;
      arg1 = vcombine_p8(vcreate_p8(UINT64_C(0x10f031a545466a60)),
                         vcreate_p8(UINT64_C(0x690ae47c5781115f)));
      set_neon_saturated();
      //  Expect: "result" = 690ae47c5781115f10f031a545466a60
      result = vreinterpretq_s64_p8(arg1);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 0);
         exp = UINT64_C(0x10f031a545466a60);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 1);
         exp = UINT64_C(0x690ae47c5781115f);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2933() {
#if __ARM_NEON_FP16_INTRINSICS

{
   {
      poly8x16_t arg1;
      float16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpretq_f16_p8\", rettype = \"float16x8_t\", argtypes = \"[poly8x16_t]\", vals = [VectorVal [PolyVal [0,1,0,1,0,0,1,1],PolyVal [1,0,0,1,0,0,1,1],PolyVal [1,0,0,0,0,0,1,0],PolyVal [1,1,1,1,1,1,0,0],PolyVal [0,1,0,0,1,1,1,0],PolyVal [0,0,0,1,0,0,0,0],PolyVal [1,0,1,1,1,1,0,0],PolyVal [1,1,1,1,1,1,0,0],PolyVal [0,0,0,0,1,1,0,1],PolyVal [0,1,1,1,1,1,0,0],PolyVal [1,1,1,0,0,0,0,0],PolyVal [0,1,1,1,1,1,0,0],PolyVal [0,1,1,0,0,0,1,0],PolyVal [1,1,0,1,1,1,1,1],PolyVal [1,0,1,1,0,1,0,0],PolyVal [1,1,1,1,1,1,0,0]]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_p8(vcreate_p8(UINT64_C(0x3f3d08723f41c9ca)),
                         vcreate_p8(UINT64_C(0x3f2dfb463e073eb0)));
      clear_neon_saturated();
      //  Expect: "result" = 3f2dfb463e073eb03f3d08723f41c9ca
      result = vreinterpretq_f16_p8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result, 0);
         exp = -11.578125;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result, 1);
         exp = 1.8134765625;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result, 2);
         exp = 1.3566017150878906e-4;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 2 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result, 3);
         exp = 1.8095703125;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 3 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result, 4);
         exp = 1.671875;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 4 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result, 5);
         exp = 1.5068359375;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 5 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result, 6);
         exp = -59584.0;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 6 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result, 7);
         exp = 1.7939453125;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 7 ", exp, got);
            }
      }
   }
}
#endif
}
void dotests_2934() {

{
   {
      poly16x8_t arg1;
      int8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpretq_s8_p16\", rettype = \"int8x16_t\", argtypes = \"[poly16x8_t]\", vals = [VectorVal [PolyVal [0,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0],PolyVal [0,1,1,1,0,0,0,0,1,1,1,1,0,0,1,0],PolyVal [1,1,1,0,0,1,1,0,0,1,0,0,1,1,0,0],PolyVal [1,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0],PolyVal [1,1,0,1,1,1,1,1,1,1,1,0,0,1,1,1],PolyVal [0,1,1,0,1,1,1,0,0,1,1,1,1,1,1,0],PolyVal [0,0,1,1,0,1,0,1,0,1,0,1,0,0,1,0],PolyVal [0,0,1,0,1,1,0,1,1,0,1,0,1,0,1,1]]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_p16(vcreate_p16(UINT64_C(0x300332674f0e003e)),
                          vcreate_p16(UINT64_C(0xd5b44aac7e76e7fb)));
      clear_neon_saturated();
      //  Expect: "result" = d5b44aac7e76e7fb300332674f0e003e
      result = vreinterpretq_s8_p16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result), 0);
         exp = UINT64_C(0x300332674f0e003e);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result), 1);
         exp = UINT64_C(0xd5b44aac7e76e7fb);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2935() {

{
   {
      poly16x8_t arg1;
      int16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpretq_s16_p16\", rettype = \"int16x8_t\", argtypes = \"[poly16x8_t]\", vals = [VectorVal [PolyVal [0,1,1,1,1,0,1,0,1,0,1,1,1,1,0,0],PolyVal [1,1,1,0,1,1,1,1,1,1,0,0,0,1,0,0],PolyVal [0,0,1,1,1,1,1,0,1,1,1,1,0,1,1,1],PolyVal [0,0,0,1,1,0,1,1,0,1,0,0,0,1,0,0],PolyVal [0,1,0,1,1,0,0,1,0,0,1,1,0,1,1,0],PolyVal [1,1,0,0,0,1,1,0,0,0,1,1,0,0,1,1],PolyVal [1,1,1,0,1,1,1,1,1,1,1,1,0,0,1,1],PolyVal [1,1,1,0,1,0,0,1,1,0,0,1,1,0,1,0]]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_p16(vcreate_p16(UINT64_C(0x22d8ef7c23f73d5e)),
                          vcreate_p16(UINT64_C(0x5997cff7cc636c9a)));
      clear_neon_saturated();
      //  Expect: "result" = 5997cff7cc636c9a22d8ef7c23f73d5e
      result = vreinterpretq_s16_p16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 0);
         exp = UINT64_C(0x22d8ef7c23f73d5e);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 1);
         exp = UINT64_C(0x5997cff7cc636c9a);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2936() {

{
   {
      poly16x8_t arg1;
      int32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpretq_s32_p16\", rettype = \"int32x4_t\", argtypes = \"[poly16x8_t]\", vals = [VectorVal [PolyVal [1,1,1,1,1,1,1,0,1,1,0,0,1,0,0,1],PolyVal [1,1,1,0,0,0,0,1,1,1,1,0,1,0,1,1],PolyVal [1,1,1,0,0,0,1,0,1,1,0,1,1,0,0,0],PolyVal [1,1,0,1,1,0,1,1,0,1,0,1,0,0,0,0],PolyVal [1,1,0,0,1,0,1,1,0,0,1,1,1,0,1,1],PolyVal [1,0,0,1,1,1,0,0,0,1,0,1,0,1,0,1],PolyVal [0,1,1,0,1,0,1,0,1,1,1,1,1,1,0,1],PolyVal [0,1,1,1,1,0,1,1,0,1,1,0,0,0,1,1]]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_p16(vcreate_p16(UINT64_C(0x0adb1b47d787937f)),
                          vcreate_p16(UINT64_C(0xc6debf56aa39dcd3)));
      clear_neon_saturated();
      //  Expect: "result" = c6debf56aa39dcd30adb1b47d787937f
      result = vreinterpretq_s32_p16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 0);
         exp = UINT64_C(0x0adb1b47d787937f);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 1);
         exp = UINT64_C(0xc6debf56aa39dcd3);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2937() {

{
   {
      poly16x8_t arg1;
      float32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpretq_f32_p16\", rettype = \"float32x4_t\", argtypes = \"[poly16x8_t]\", vals = [VectorVal [PolyVal [1,0,0,0,0,0,1,0,0,0,1,1,0,1,0,1],PolyVal [0,1,1,0,1,1,1,0,1,1,1,1,1,1,0,0],PolyVal [0,0,0,0,1,1,1,0,0,0,0,0,0,1,1,1],PolyVal [1,1,0,0,0,1,1,0,1,1,1,1,1,1,0,0],PolyVal [0,0,0,1,1,1,1,0,0,0,1,1,0,0,0,1],PolyVal [0,0,1,1,0,0,0,0,1,1,1,1,1,1,0,0],PolyVal [0,1,1,0,0,1,0,1,1,1,0,1,1,1,1,1],PolyVal [0,1,0,1,0,0,1,0,1,1,1,1,1,1,0,0]]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_p16(vcreate_p16(UINT64_C(0x3f63e0703f76ac41)),
                          vcreate_p16(UINT64_C(0x3f4afba63f0c8c78)));
      clear_neon_saturated();
      //  Expect: "result" = 3f4afba63f0c8c783f63e0703f76ac41
      result = vreinterpretq_f32_p16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 0);
         exp = ((float32_t) 0.9635658860206604);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 1);
         exp = ((float32_t) 0.8901433944702148);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 2);
         exp = ((float32_t) 0.549018383026123);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 2 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 3);
         exp = ((float32_t) 0.7929023504257202);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 3 ", exp, got);
            }
      }
   }
}
}
void dotests_2938() {

{
   {
      poly16x8_t arg1;
      uint8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpretq_u8_p16\", rettype = \"uint8x16_t\", argtypes = \"[poly16x8_t]\", vals = [VectorVal [PolyVal [1,0,1,0,1,1,0,0,0,1,0,0,0,0,1,0],PolyVal [1,1,1,1,0,0,1,0,0,0,0,1,1,0,0,1],PolyVal [1,0,0,0,0,1,1,0,1,0,1,0,1,1,1,1],PolyVal [1,1,1,1,0,0,1,0,0,0,0,0,1,1,1,1],PolyVal [1,0,1,0,1,1,1,1,0,0,0,1,1,1,1,1],PolyVal [0,0,0,1,0,1,1,1,0,1,0,1,1,0,0,0],PolyVal [0,0,0,0,0,1,1,0,0,1,1,1,0,1,1,0],PolyVal [1,0,0,0,1,1,0,0,1,1,0,1,0,1,0,0]]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_p16(vcreate_p16(UINT64_C(0xf04ff561984f4235)),
                          vcreate_p16(UINT64_C(0x2b316e601ae8f8f5)));
      clear_neon_saturated();
      //  Expect: "result" = 2b316e601ae8f8f5f04ff561984f4235
      result = vreinterpretq_u8_p16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 0);
         exp = UINT64_C(0xf04ff561984f4235);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 1);
         exp = UINT64_C(0x2b316e601ae8f8f5);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2939() {

{
   {
      poly16x8_t arg1;
      uint16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpretq_u16_p16\", rettype = \"uint16x8_t\", argtypes = \"[poly16x8_t]\", vals = [VectorVal [PolyVal [0,1,1,0,0,0,1,0,0,0,0,0,0,0,0,1],PolyVal [0,0,1,0,0,1,0,0,0,1,1,1,0,1,1,1],PolyVal [1,1,1,0,0,1,1,1,0,1,1,0,1,1,0,0],PolyVal [1,1,1,1,1,0,1,1,0,1,1,1,0,1,0,1],PolyVal [1,0,1,0,0,0,1,0,0,1,1,1,1,0,1,0],PolyVal [0,0,1,1,1,0,0,0,1,1,1,0,1,0,1,0],PolyVal [0,0,0,0,0,0,1,0,1,0,1,1,0,0,1,1],PolyVal [1,0,1,1,0,0,1,1,1,1,0,0,0,0,0,1]]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_p16(vcreate_p16(UINT64_C(0xaedf36e7ee248046)),
                          vcreate_p16(UINT64_C(0x83cdcd40571c5e45)));
      clear_neon_saturated();
      //  Expect: "result" = 83cdcd40571c5e45aedf36e7ee248046
      result = vreinterpretq_u16_p16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 0);
         exp = UINT64_C(0xaedf36e7ee248046);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 1);
         exp = UINT64_C(0x83cdcd40571c5e45);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2940() {

{
   {
      poly16x8_t arg1;
      uint32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpretq_u32_p16\", rettype = \"uint32x4_t\", argtypes = \"[poly16x8_t]\", vals = [VectorVal [PolyVal [0,0,0,0,1,0,1,1,0,1,0,0,1,1,1,1],PolyVal [1,1,0,0,1,1,0,1,1,1,1,0,1,0,0,1],PolyVal [1,1,0,0,0,1,0,1,0,0,1,1,1,0,0,1],PolyVal [0,0,0,0,0,1,0,1,0,1,1,0,0,0,1,0],PolyVal [0,0,0,1,1,1,1,0,1,1,0,0,0,0,1,0],PolyVal [1,1,1,0,1,0,0,0,0,0,0,1,1,0,1,0],PolyVal [0,0,1,1,1,1,1,1,1,1,1,0,1,1,0,1],PolyVal [1,1,1,1,1,1,0,1,0,0,1,0,1,1,1,0]]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_p16(vcreate_p16(UINT64_C(0x46a09ca397b3f2d0)),
                          vcreate_p16(UINT64_C(0x74bfb7fc58174378)));
      clear_neon_saturated();
      //  Expect: "result" = 74bfb7fc5817437846a09ca397b3f2d0
      result = vreinterpretq_u32_p16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 0);
         exp = UINT64_C(0x46a09ca397b3f2d0);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 1);
         exp = UINT64_C(0x74bfb7fc58174378);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2941() {

{
   {
      poly16x8_t arg1;
      poly8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpretq_p8_p16\", rettype = \"poly8x16_t\", argtypes = \"[poly16x8_t]\", vals = [VectorVal [PolyVal [0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0],PolyVal [1,0,0,0,1,1,1,1,1,1,1,0,0,1,1,0],PolyVal [0,0,1,1,0,1,0,0,1,1,0,1,1,1,0,1],PolyVal [1,1,0,0,0,1,1,0,1,1,0,0,0,1,0,1],PolyVal [0,0,1,1,0,0,0,1,1,0,0,0,0,1,0,1],PolyVal [0,0,1,0,0,1,1,0,1,0,1,1,0,0,0,0],PolyVal [1,0,0,0,1,0,1,0,0,1,1,1,1,0,1,1],PolyVal [1,1,1,1,0,0,0,0,0,0,1,0,0,0,1,0]]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_p16(vcreate_p16(UINT64_C(0xa363bb2c67f10348)),
                          vcreate_p16(UINT64_C(0x440fde510d64a18c)));
      clear_neon_saturated();
      //  Expect: "result" = 440fde510d64a18ca363bb2c67f10348
      result = vreinterpretq_p8_p16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p8(result), 0);
         exp = UINT64_C(0xa363bb2c67f10348);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p8(result), 1);
         exp = UINT64_C(0x440fde510d64a18c);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2942() {

{
   {
      poly16x8_t arg1;
      uint64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpretq_u64_p16\", rettype = \"uint64x2_t\", argtypes = \"[poly16x8_t]\", vals = [VectorVal [PolyVal [1,1,1,1,1,1,1,1,0,0,0,1,1,0,0,1],PolyVal [0,0,0,1,1,0,1,1,0,0,0,0,1,1,1,0],PolyVal [0,1,0,1,0,0,0,0,0,0,0,1,0,1,1,0],PolyVal [0,1,0,1,0,1,0,1,0,0,0,1,1,1,1,1],PolyVal [1,1,1,1,1,0,1,1,0,0,1,1,0,0,0,0],PolyVal [1,0,0,1,0,1,1,0,1,0,1,0,0,1,1,0],PolyVal [0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1],PolyVal [1,1,1,0,1,0,0,0,0,1,0,0,1,1,1,1]]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_p16(vcreate_p16(UINT64_C(0xf8aa680a70d898ff)),
                          vcreate_p16(UINT64_C(0xf217812265690cdf)));
      clear_neon_saturated();
      //  Expect: "result" = f217812265690cdff8aa680a70d898ff
      result = vreinterpretq_u64_p16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 0);
         exp = UINT64_C(0xf8aa680a70d898ff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 1);
         exp = UINT64_C(0xf217812265690cdf);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2943() {

{
   {
      poly16x8_t arg1;
      int64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpretq_s64_p16\", rettype = \"int64x2_t\", argtypes = \"[poly16x8_t]\", vals = [VectorVal [PolyVal [1,1,0,0,0,1,0,1,0,0,1,0,1,1,1,1],PolyVal [0,0,1,1,0,0,0,0,1,0,1,1,0,1,1,0],PolyVal [1,0,0,0,1,1,1,0,0,1,0,0,0,0,1,1],PolyVal [0,0,0,1,1,0,0,1,1,0,1,1,1,1,0,0],PolyVal [0,0,1,0,0,0,0,0,0,1,1,0,1,0,1,1],PolyVal [1,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0],PolyVal [1,0,1,1,1,0,1,0,0,0,1,1,1,1,0,1],PolyVal [1,0,0,0,0,1,0,1,0,1,0,0,1,0,0,0]]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_p16(vcreate_p16(UINT64_C(0x3d98c2716d0cf4a3)),
                          vcreate_p16(UINT64_C(0x12a1bc5d3003d604)));
      clear_neon_saturated();
      //  Expect: "result" = 12a1bc5d3003d6043d98c2716d0cf4a3
      result = vreinterpretq_s64_p16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 0);
         exp = UINT64_C(0x3d98c2716d0cf4a3);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 1);
         exp = UINT64_C(0x12a1bc5d3003d604);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2944() {
#if __ARM_NEON_FP16_INTRINSICS

{
   {
      poly16x8_t arg1;
      float16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpretq_f16_p16\", rettype = \"float16x8_t\", argtypes = \"[poly16x8_t]\", vals = [VectorVal [PolyVal [0,0,0,1,0,1,1,0,1,0,0,0,1,1,0,0],PolyVal [0,0,0,0,0,1,0,1,0,1,1,1,1,1,0,0],PolyVal [0,0,0,0,1,1,0,1,0,1,0,1,1,0,1,1],PolyVal [1,1,1,1,1,1,0,0,1,0,1,1,1,1,0,0],PolyVal [0,0,1,1,0,0,0,1,1,1,1,1,1,1,0,0],PolyVal [0,0,1,0,0,1,1,0,1,1,1,1,1,1,0,0],PolyVal [0,0,1,0,0,1,1,1,1,1,1,1,1,0,0,1],PolyVal [0,1,1,1,1,1,0,1,0,1,1,1,1,1,0,0]]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_p16(vcreate_p16(UINT64_C(0x3d3fdab03ea03168)),
                          vcreate_p16(UINT64_C(0x3ebe9fe43f643f8c)));
      clear_neon_saturated();
      //  Expect: "result" = 3ebe9fe43f643f8c3d3fdab03ea03168
      result = vreinterpretq_f16_p16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result, 0);
         exp = 0.1689453125;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result, 1);
         exp = 1.65625;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result, 2);
         exp = -214.0;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 2 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result, 3);
         exp = 1.3115234375;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 3 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result, 4);
         exp = 1.88671875;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 4 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result, 5);
         exp = 1.84765625;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 5 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result, 6);
         exp = -7.7056884765625e-3;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 6 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result, 7);
         exp = 1.685546875;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 7 ", exp, got);
            }
      }
   }
}
#endif
}
void dotests_2945() {

{
   {
      uint64x2_t arg1;
      int8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpretq_s8_u64\", rettype = \"int8x16_t\", argtypes = \"[uint64x2_t]\", vals = [VectorVal [IntegerVal 9223372034707324927,IntegerVal 9223231297218872135]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u64(vcreate_u64(UINT64_C(0x7fffffff80007fff)),
                          vcreate_u64(UINT64_C(0x7fff7fff7fff0347)));
      clear_neon_saturated();
      //  Expect: "result" = 7fff7fff7fff03477fffffff80007fff
      result = vreinterpretq_s8_u64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result), 0);
         exp = UINT64_C(0x7fffffff80007fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result), 1);
         exp = UINT64_C(0x7fff7fff7fff0347);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2946() {

{
   {
      uint64x2_t arg1;
      int16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpretq_s16_u64\", rettype = \"int16x8_t\", argtypes = \"[uint64x2_t]\", vals = [VectorVal [IntegerVal 9223090564025483264,IntegerVal 281474976710655]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u64(vcreate_u64(UINT64_C(0x7fff00007fff0000)),
                          vcreate_u64(UINT64_C(0x0000ffffffffffff)));
      clear_neon_saturated();
      //  Expect: "result" = 0000ffffffffffff7fff00007fff0000
      result = vreinterpretq_s16_u64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 0);
         exp = UINT64_C(0x7fff00007fff0000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 1);
         exp = UINT64_C(0x0000ffffffffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2947() {

{
   {
      uint64x2_t arg1;
      int32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpretq_s32_u64\", rettype = \"int32x4_t\", argtypes = \"[uint64x2_t]\", vals = [VectorVal [IntegerVal 9223512770048196607,IntegerVal 18446603331956080639]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u64(vcreate_u64(UINT64_C(0x80007fff00007fff)),
                          vcreate_u64(UINT64_C(0xffff7fff01c77fff)));
      clear_neon_saturated();
      //  Expect: "result" = ffff7fff01c77fff80007fff00007fff
      result = vreinterpretq_s32_u64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 0);
         exp = UINT64_C(0x80007fff00007fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 1);
         exp = UINT64_C(0xffff7fff01c77fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2948() {

{
   {
      uint64x2_t arg1;
      float32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpretq_f32_u64\", rettype = \"float32x4_t\", argtypes = \"[uint64x2_t]\", vals = [VectorVal [IntegerVal 4550591758950139780,IntegerVal 4568818968806371456]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u64(vcreate_u64(UINT64_C(0x3f26f3183e0b0784)),
                          vcreate_u64(UINT64_C(0x3f67b4a53ec53080)));
      clear_neon_saturated();
      //  Expect: "result" = 3f67b4a53ec530803f26f3183e0b0784
      result = vreinterpretq_f32_u64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 0);
         exp = ((float32_t) 0.13577085733413696);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 1);
         exp = ((float32_t) 0.6521468162536621);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 2);
         exp = ((float32_t) 0.3851356506347656);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 2 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 3);
         exp = ((float32_t) 0.9051001667976379);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 3 ", exp, got);
            }
      }
   }
}
}
void dotests_2949() {

{
   {
      uint64x2_t arg1;
      uint8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpretq_u8_u64\", rettype = \"uint8x16_t\", argtypes = \"[uint64x2_t]\", vals = [VectorVal [IntegerVal 9223372034254498410,IntegerVal 3956438813395386368]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u64(vcreate_u64(UINT64_C(0x7fffffff6502ea6a)),
                          vcreate_u64(UINT64_C(0x36e8182380000000)));
      clear_neon_saturated();
      //  Expect: "result" = 36e81823800000007fffffff6502ea6a
      result = vreinterpretq_u8_u64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 0);
         exp = UINT64_C(0x7fffffff6502ea6a);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 1);
         exp = UINT64_C(0x36e8182380000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2950() {

{
   {
      uint64x2_t arg1;
      uint16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpretq_u16_u64\", rettype = \"uint16x8_t\", argtypes = \"[uint64x2_t]\", vals = [VectorVal [IntegerVal 9223090566140975479,IntegerVal 129874207408127]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u64(vcreate_u64(UINT64_C(0x7fff0000fe16d977)),
                          vcreate_u64(UINT64_C(0x0000761eb1ff7fff)));
      clear_neon_saturated();
      //  Expect: "result" = 0000761eb1ff7fff7fff0000fe16d977
      result = vreinterpretq_u16_u64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 0);
         exp = UINT64_C(0x7fff0000fe16d977);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 1);
         exp = UINT64_C(0x0000761eb1ff7fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2951() {

{
   {
      uint64x2_t arg1;
      uint32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpretq_u32_u64\", rettype = \"uint32x4_t\", argtypes = \"[uint64x2_t]\", vals = [VectorVal [IntegerVal 9223653509684002816,IntegerVal 9223512772195647488]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u64(vcreate_u64(UINT64_C(0x8000ffff80000000)),
                          vcreate_u64(UINT64_C(0x80007fff80000000)));
      clear_neon_saturated();
      //  Expect: "result" = 80007fff800000008000ffff80000000
      result = vreinterpretq_u32_u64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 0);
         exp = UINT64_C(0x8000ffff80000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 1);
         exp = UINT64_C(0x80007fff80000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2952() {

{
   {
      uint64x2_t arg1;
      poly8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpretq_p8_u64\", rettype = \"poly8x16_t\", argtypes = \"[uint64x2_t]\", vals = [VectorVal [IntegerVal 4294934528,IntegerVal 2519763991513825279]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u64(vcreate_u64(UINT64_C(0x00000000ffff8000)),
                          vcreate_u64(UINT64_C(0x22f8000000007fff)));
      clear_neon_saturated();
      //  Expect: "result" = 22f8000000007fff00000000ffff8000
      result = vreinterpretq_p8_u64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p8(result), 0);
         exp = UINT64_C(0x00000000ffff8000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p8(result), 1);
         exp = UINT64_C(0x22f8000000007fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2953() {

{
   {
      uint64x2_t arg1;
      poly16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpretq_p16_u64\", rettype = \"poly16x8_t\", argtypes = \"[uint64x2_t]\", vals = [VectorVal [IntegerVal 10425129449920932773,IntegerVal 9223231297218904353]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u64(vcreate_u64(UINT64_C(0x90ad800000002ba5)),
                          vcreate_u64(UINT64_C(0x7fff7fff7fff8121)));
      clear_neon_saturated();
      //  Expect: "result" = 7fff7fff7fff812190ad800000002ba5
      result = vreinterpretq_p16_u64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p16(result), 0);
         exp = UINT64_C(0x90ad800000002ba5);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p16(result), 1);
         exp = UINT64_C(0x7fff7fff7fff8121);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2954() {

{
   {
      uint64x2_t arg1;
      int64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpretq_s64_u64\", rettype = \"int64x2_t\", argtypes = \"[uint64x2_t]\", vals = [VectorVal [IntegerVal 15745569459705741311,IntegerVal 18446603340516098048]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u64(vcreate_u64(UINT64_C(0xda837fffffffffff)),
                          vcreate_u64(UINT64_C(0xffff8000ffff0000)));
      clear_neon_saturated();
      //  Expect: "result" = ffff8000ffff0000da837fffffffffff
      result = vreinterpretq_s64_u64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 0);
         exp = UINT64_C(0xda837fffffffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 1);
         exp = UINT64_C(0xffff8000ffff0000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2955() {
#if __ARM_NEON_FP16_INTRINSICS

{
   {
      uint64x2_t arg1;
      float16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpretq_f16_u64\", rettype = \"float16x8_t\", argtypes = \"[uint64x2_t]\", vals = [VectorVal [IntegerVal 4559383969336636834,IntegerVal 4527376481467870836]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u64(vcreate_u64(UINT64_C(0x3f462f903eebb5a2)),
                          vcreate_u64(UINT64_C(0x3ed478ec3e59ae74)));
      clear_neon_saturated();
      //  Expect: "result" = 3ed478ec3e59ae743f462f903eebb5a2
      result = vreinterpretq_f16_u64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result, 0);
         exp = -0.35205078125;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result, 1);
         exp = 1.7294921875;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result, 2);
         exp = 0.1181640625;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 2 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result, 3);
         exp = 1.818359375;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 3 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result, 4);
         exp = -0.100830078125;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 4 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result, 5);
         exp = 1.5869140625;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 5 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result, 6);
         exp = 40320.0;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 6 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result, 7);
         exp = 1.70703125;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 7 ", exp, got);
            }
      }
   }
}
#endif
}
void dotests_2956() {

{
   {
      int64x2_t arg1;
      int8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpretq_s8_s64\", rettype = \"int8x16_t\", argtypes = \"[int64x2_t]\", vals = [VectorVal [IntegerVal 2147483647,IntegerVal (-4002574166678077440)]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s64(vcreate_s64(UINT64_C(0x000000007fffffff)),
                          vcreate_s64(UINT64_C(0xc87400007fff8000)));
      clear_neon_saturated();
      //  Expect: "result" = c87400007fff8000000000007fffffff
      result = vreinterpretq_s8_s64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result), 0);
         exp = UINT64_C(0x000000007fffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result), 1);
         exp = UINT64_C(0xc87400007fff8000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2957() {

{
   {
      int64x2_t arg1;
      int16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpretq_s16_s64\", rettype = \"int16x8_t\", argtypes = \"[int64x2_t]\", vals = [VectorVal [IntegerVal (-9223231297218969601),IntegerVal 9223231299366453248]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s64(vcreate_s64(UINT64_C(0x800080007fff7fff)),
                          vcreate_s64(UINT64_C(0x7fff800000008000)));
      clear_neon_saturated();
      //  Expect: "result" = 7fff800000008000800080007fff7fff
      result = vreinterpretq_s16_s64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 0);
         exp = UINT64_C(0x800080007fff7fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 1);
         exp = UINT64_C(0x7fff800000008000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2958() {

{
   {
      int64x2_t arg1;
      int32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpretq_s32_s64\", rettype = \"int32x4_t\", argtypes = \"[int64x2_t]\", vals = [VectorVal [IntegerVal (-9223090565828050944),IntegerVal (-7970386180174787066)]], start_saturated = True}";
      int reported = 0;
      arg1 = vcombine_s64(vcreate_s64(UINT64_C(0x8000ffff14900000)),
                          vcreate_s64(UINT64_C(0x91637fff7fffce06)));
      set_neon_saturated();
      //  Expect: "result" = 91637fff7fffce068000ffff14900000
      result = vreinterpretq_s32_s64(arg1);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 0);
         exp = UINT64_C(0x8000ffff14900000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 1);
         exp = UINT64_C(0x91637fff7fffce06);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2959() {

{
   {
      int64x2_t arg1;
      float32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpretq_f32_s64\", rettype = \"float32x4_t\", argtypes = \"[int64x2_t]\", vals = [VectorVal [IntegerVal 4499703560514259296,IntegerVal 4485293429837616638]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s64(vcreate_s64(UINT64_C(0x3e72288c3f034960)),
                          vcreate_s64(UINT64_C(0x3e3ef69c3edd55fe)));
      clear_neon_saturated();
      //  Expect: "result" = 3e3ef69c3edd55fe3e72288c3f034960
      result = vreinterpretq_f32_s64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 0);
         exp = ((float32_t) 0.5128383636474609);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 1);
         exp = ((float32_t) 0.23648279905319214);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 2);
         exp = ((float32_t) 0.4322966933250427);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 2 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 3);
         exp = ((float32_t) 0.18648761510849);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 3 ", exp, got);
            }
      }
   }
}
}
void dotests_2960() {

{
   {
      int64x2_t arg1;
      uint8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpretq_u8_s64\", rettype = \"uint8x16_t\", argtypes = \"[int64x2_t]\", vals = [VectorVal [IntegerVal 9223090566172999679,IntegerVal 140734633836543]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s64(vcreate_s64(UINT64_C(0x7fff0000ffff7fff)),
                          vcreate_s64(UINT64_C(0x00007fff55db7fff)));
      clear_neon_saturated();
      //  Expect: "result" = 00007fff55db7fff7fff0000ffff7fff
      result = vreinterpretq_u8_s64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 0);
         exp = UINT64_C(0x7fff0000ffff7fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 1);
         exp = UINT64_C(0x00007fff55db7fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2961() {

{
   {
      int64x2_t arg1;
      uint16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpretq_u16_s64\", rettype = \"uint16x8_t\", argtypes = \"[int64x2_t]\", vals = [VectorVal [IntegerVal 239472344006655,IntegerVal (-93314606956545)]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s64(vcreate_s64(UINT64_C(0x0000d9cc7fff7fff)),
                          vcreate_s64(UINT64_C(0xffffab217fffffff)));
      clear_neon_saturated();
      //  Expect: "result" = ffffab217fffffff0000d9cc7fff7fff
      result = vreinterpretq_u16_s64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 0);
         exp = UINT64_C(0x0000d9cc7fff7fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 1);
         exp = UINT64_C(0xffffab217fffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2962() {

{
   {
      int64x2_t arg1;
      uint32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpretq_u32_s64\", rettype = \"uint32x4_t\", argtypes = \"[int64x2_t]\", vals = [VectorVal [IntegerVal (-6291669412630003713),IntegerVal 207479952542772]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s64(vcreate_s64(UINT64_C(0xa8af8000ffff7fff)),
                          vcreate_s64(UINT64_C(0x0000bcb3b0de8c34)));
      clear_neon_saturated();
      //  Expect: "result" = 0000bcb3b0de8c34a8af8000ffff7fff
      result = vreinterpretq_u32_s64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 0);
         exp = UINT64_C(0xa8af8000ffff7fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 1);
         exp = UINT64_C(0x0000bcb3b0de8c34);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2963() {

{
   {
      int64x2_t arg1;
      poly8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpretq_p8_s64\", rettype = \"poly8x16_t\", argtypes = \"[int64x2_t]\", vals = [VectorVal [IntegerVal 9223206174702833902,IntegerVal (-9223090564025581569)]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s64(vcreate_s64(UINT64_C(0x7fff6926355a10ee)),
                          vcreate_s64(UINT64_C(0x8000ffff7fff7fff)));
      clear_neon_saturated();
      //  Expect: "result" = 8000ffff7fff7fff7fff6926355a10ee
      result = vreinterpretq_p8_s64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p8(result), 0);
         exp = UINT64_C(0x7fff6926355a10ee);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p8(result), 1);
         exp = UINT64_C(0x8000ffff7fff7fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2964() {

{
   {
      int64x2_t arg1;
      poly16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpretq_p16_s64\", rettype = \"poly16x8_t\", argtypes = \"[int64x2_t]\", vals = [VectorVal [IntegerVal 9223231301800558592,IntegerVal 259527693828096]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s64(vcreate_s64(UINT64_C(0x7fff800091160000)),
                          vcreate_s64(UINT64_C(0x0000ec0a00000000)));
      clear_neon_saturated();
      //  Expect: "result" = 0000ec0a000000007fff800091160000
      result = vreinterpretq_p16_s64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p16(result), 0);
         exp = UINT64_C(0x7fff800091160000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p16(result), 1);
         exp = UINT64_C(0x0000ec0a00000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2965() {

{
   {
      int64x2_t arg1;
      uint64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpretq_u64_s64\", rettype = \"uint64x2_t\", argtypes = \"[int64x2_t]\", vals = [VectorVal [IntegerVal 140733193420800,IntegerVal (-75290776666112)]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s64(vcreate_s64(UINT64_C(0x00007fff00008000)),
                          vcreate_s64(UINT64_C(0xffffbb8600008000)));
      clear_neon_saturated();
      //  Expect: "result" = ffffbb860000800000007fff00008000
      result = vreinterpretq_u64_s64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 0);
         exp = UINT64_C(0x00007fff00008000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 1);
         exp = UINT64_C(0xffffbb8600008000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2966() {
#if __ARM_NEON_FP16_INTRINSICS

{
   {
      int64x2_t arg1;
      float16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpretq_f16_s64\", rettype = \"float16x8_t\", argtypes = \"[int64x2_t]\", vals = [VectorVal [IntegerVal 4517541427281613923,IntegerVal 4486662888752996717]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s64(vcreate_s64(UINT64_C(0x3eb187fe3f3b5463)),
                          vcreate_s64(UINT64_C(0x3e43d4203f0ce16d)));
      clear_neon_saturated();
      //  Expect: "result" = 3e43d4203f0ce16d3eb187fe3f3b5463
      result = vreinterpretq_f16_s64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result, 0);
         exp = 70.1875;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result, 1);
         exp = 1.8076171875;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result, 2);
         exp = -1.2195110321044922e-4;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 2 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result, 3);
         exp = 1.6728515625;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 3 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result, 4);
         exp = -694.5;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 4 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result, 5);
         exp = 1.76171875;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 5 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result, 6);
         exp = -66.0;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 6 ", exp, got);
            }
      }
      {
         __fp16 got;
         __fp16 exp;
         got = vgetq_lane_f16(result, 7);
         exp = 1.5654296875;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 7 ", exp, got);
            }
      }
   }
}
#endif
}
void dotests_2967() {
#if __ARM_NEON_FP16_INTRINSICS

{
   {
      float16x8_t arg1;
      int8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpretq_s8_f16\", rettype = \"int8x16_t\", argtypes = \"[float16x8_t]\", vals = [VectorVal [FloatVal (-6.987380961353644),FloatVal (-0.2889116074789815),FloatVal (-3.5901930607758104),FloatVal 0.33895373615043134,FloatVal (-1.0931974972212188),FloatVal 8.177715505335925,FloatVal (-0.1873525885159406),FloatVal (-2.7988181819069036)]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_f16(vcreate_f16(UINT64_C(0x356cc32eb49fc6fc)),
                          vcreate_f16(UINT64_C(0xc198b1fe4816bc5f)));
      clear_neon_saturated();
      //  Expect: "result" = c198b1fe4816bc5f356cc32eb49fc6fc
      result = vreinterpretq_s8_f16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result), 0);
         exp = UINT64_C(0x356cc32eb49fc6fc);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result), 1);
         exp = UINT64_C(0xc198b1fe4816bc5f);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
#endif
}
void dotests_2968() {
#if __ARM_NEON_FP16_INTRINSICS

{
   {
      float16x8_t arg1;
      int16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpretq_s16_f16\", rettype = \"int16x8_t\", argtypes = \"[float16x8_t]\", vals = [VectorVal [FloatVal 2.6790074160045467,FloatVal 8.031482873368205,FloatVal 1.4999442937486194,FloatVal (-2.243871004934972),FloatVal 3.146460383542916,FloatVal 8.42076956080663,FloatVal (-3.717915910072522),FloatVal 6.664241078505935]], start_saturated = True}";
      int reported = 0;
      arg1 = vcombine_f16(vcreate_f16(UINT64_C(0xc07c3dff4804415b)),
                          vcreate_f16(UINT64_C(0x46aac36f4835424a)));
      set_neon_saturated();
      //  Expect: "result" = 46aac36f4835424ac07c3dff4804415b
      result = vreinterpretq_s16_f16(arg1);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 0);
         exp = UINT64_C(0xc07c3dff4804415b);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 1);
         exp = UINT64_C(0x46aac36f4835424a);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
#endif
}
void dotests_2969() {
#if __ARM_NEON_FP16_INTRINSICS

{
   {
      float16x8_t arg1;
      int32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpretq_s32_f16\", rettype = \"int32x4_t\", argtypes = \"[float16x8_t]\", vals = [VectorVal [FloatVal (-1.4207945084104967),FloatVal (-2.2592368117712214),FloatVal (-8.579861059745294),FloatVal 5.1955605667578215,FloatVal (-4.911623899167276),FloatVal (-3.9154244579754494),FloatVal (-1.4541847797648835),FloatVal (-3.907254763786727)]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_f16(vcreate_f16(UINT64_C(0x4532c84ac084bdae)),
                          vcreate_f16(UINT64_C(0xc3d0bdd1c3d4c4e9)));
      clear_neon_saturated();
      //  Expect: "result" = c3d0bdd1c3d4c4e94532c84ac084bdae
      result = vreinterpretq_s32_f16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 0);
         exp = UINT64_C(0x4532c84ac084bdae);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 1);
         exp = UINT64_C(0xc3d0bdd1c3d4c4e9);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
#endif
}
void dotests_2970() {
#if __ARM_NEON_FP16_INTRINSICS

{
   {
      float16x8_t arg1;
      float32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpretq_f32_f16\", rettype = \"float32x4_t\", argtypes = \"[float16x8_t]\", vals = [VectorVal [FloatVal 3.62548828125e-2,FloatVal 1.8134765625,FloatVal 1764.0,FloatVal 1.646484375,FloatVal 2.582550048828125e-3,FloatVal 1.6357421875,FloatVal 4040.0,FloatVal 1.6806640625]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_f16(vcreate_f16(UINT64_C(0x3e9666e43f4128a4)),
                          vcreate_f16(UINT64_C(0x3eb96be43e8b194a)));
      clear_neon_saturated();
      //  Expect: "result" = 3eb96be43e8b194a3e9666e43f4128a4
      result = vreinterpretq_f32_f16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 0);
         exp = ((float32_t) 0.7545263767242432);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 1);
         exp = ((float32_t) 0.2937537431716919);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 2);
         exp = ((float32_t) 0.27167731523513794);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 2 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 3);
         exp = ((float32_t) 0.36215126514434814);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 3 ", exp, got);
            }
      }
   }
}
#endif
}
void dotests_2971() {
#if __ARM_NEON_FP16_INTRINSICS

{
   {
      float16x8_t arg1;
      uint8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpretq_u8_f16\", rettype = \"uint8x16_t\", argtypes = \"[float16x8_t]\", vals = [VectorVal [FloatVal 5.857784482073507,FloatVal 7.19569282846248,FloatVal (-8.815689912947066),FloatVal (-2.4749402783241337),FloatVal 6.719578971975359,FloatVal 2.8680457662136654,FloatVal (-6.457829352857932),FloatVal (-1.9001501431152938)]], start_saturated = True}";
      int reported = 0;
      arg1 = vcombine_f16(vcreate_f16(UINT64_C(0xc0f3c868473245db)),
                          vcreate_f16(UINT64_C(0xbf99c67541bc46b8)));
      set_neon_saturated();
      //  Expect: "result" = bf99c67541bc46b8c0f3c868473245db
      result = vreinterpretq_u8_f16(arg1);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 0);
         exp = UINT64_C(0xc0f3c868473245db);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 1);
         exp = UINT64_C(0xbf99c67541bc46b8);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
#endif
}
void dotests_2972() {
#if __ARM_NEON_FP16_INTRINSICS

{
   {
      float16x8_t arg1;
      uint16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpretq_u16_f16\", rettype = \"uint16x8_t\", argtypes = \"[float16x8_t]\", vals = [VectorVal [FloatVal (-8.568702623167288),FloatVal (-6.776093691719862),FloatVal (-2.08366736801789),FloatVal 0.23077015917804822,FloatVal 7.302750483097512,FloatVal 4.224299445088809,FloatVal (-3.133969696650669),FloatVal (-5.283253502263808)]], start_saturated = True}";
      int reported = 0;
      arg1 = vcombine_f16(vcreate_f16(UINT64_C(0x3362c02ac6c6c848)),
                          vcreate_f16(UINT64_C(0xc548c2444439474d)));
      set_neon_saturated();
      //  Expect: "result" = c548c2444439474d3362c02ac6c6c848
      result = vreinterpretq_u16_f16(arg1);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 0);
         exp = UINT64_C(0x3362c02ac6c6c848);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 1);
         exp = UINT64_C(0xc548c2444439474d);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
#endif
}
void dotests_2973() {
#if __ARM_NEON_FP16_INTRINSICS

{
   {
      float16x8_t arg1;
      uint32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpretq_u32_f16\", rettype = \"uint32x4_t\", argtypes = \"[float16x8_t]\", vals = [VectorVal [FloatVal (-2.5484591754298265),FloatVal 1.6960388968571465,FloatVal (-4.710720167001197),FloatVal (-4.837740822067165),FloatVal 7.402069806806402,FloatVal (-0.5621082547708376),FloatVal (-3.1903656664081304),FloatVal 1.0186725219480035]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_f16(vcreate_f16(UINT64_C(0xc4d6c4b53ec8c118)),
                          vcreate_f16(UINT64_C(0x3c13c261b87f4766)));
      clear_neon_saturated();
      //  Expect: "result" = 3c13c261b87f4766c4d6c4b53ec8c118
      result = vreinterpretq_u32_f16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 0);
         exp = UINT64_C(0xc4d6c4b53ec8c118);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 1);
         exp = UINT64_C(0x3c13c261b87f4766);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
#endif
}
void dotests_2974() {
#if __ARM_NEON_FP16_INTRINSICS

{
   {
      float16x8_t arg1;
      poly8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpretq_p8_f16\", rettype = \"poly8x16_t\", argtypes = \"[float16x8_t]\", vals = [VectorVal [FloatVal 6.514182533962231,FloatVal 1.7969460661035637,FloatVal 0.9601805771461773,FloatVal (-1.1471376103455366),FloatVal 8.30347786360758,FloatVal 7.420660080913958,FloatVal 9.378511714398616,FloatVal 8.653850156036672]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_f16(vcreate_f16(UINT64_C(0xbc963bae3f304683)),
                          vcreate_f16(UINT64_C(0x485348b0476b4826)));
      clear_neon_saturated();
      //  Expect: "result" = 485348b0476b4826bc963bae3f304683
      result = vreinterpretq_p8_f16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p8(result), 0);
         exp = UINT64_C(0xbc963bae3f304683);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p8(result), 1);
         exp = UINT64_C(0x485348b0476b4826);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
#endif
}
void dotests_2975() {
#if __ARM_NEON_FP16_INTRINSICS

{
   {
      float16x8_t arg1;
      poly16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpretq_p16_f16\", rettype = \"poly16x8_t\", argtypes = \"[float16x8_t]\", vals = [VectorVal [FloatVal (-1.0529886412490832),FloatVal (-1.981667577248631),FloatVal 7.087225145314303,FloatVal 0.16978005539965224,FloatVal 4.665227872137468,FloatVal (-6.575041408207188),FloatVal 7.285202342667361,FloatVal (-1.3062627796957855)]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_f16(vcreate_f16(UINT64_C(0x316e4716bfedbc36)),
                          vcreate_f16(UINT64_C(0xbd394749c69344aa)));
      clear_neon_saturated();
      //  Expect: "result" = bd394749c69344aa316e4716bfedbc36
      result = vreinterpretq_p16_f16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p16(result), 0);
         exp = UINT64_C(0x316e4716bfedbc36);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p16(result), 1);
         exp = UINT64_C(0xbd394749c69344aa);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
#endif
}
void dotests_2976() {
#if __ARM_NEON_FP16_INTRINSICS

{
   {
      float16x8_t arg1;
      uint64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpretq_u64_f16\", rettype = \"uint64x2_t\", argtypes = \"[float16x8_t]\", vals = [VectorVal [FloatVal 8.219655099705324,FloatVal 8.037335128574,FloatVal (-5.24545325622025),FloatVal (-5.787721689151062),FloatVal (-5.601062657581821),FloatVal (-6.245194794208853),FloatVal 7.987019741579648,FloatVal (-9.470472915879045)]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_f16(vcreate_f16(UINT64_C(0xc5c9c53e4804481c)),
                          vcreate_f16(UINT64_C(0xc8bc47fcc63ec599)));
      clear_neon_saturated();
      //  Expect: "result" = c8bc47fcc63ec599c5c9c53e4804481c
      result = vreinterpretq_u64_f16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 0);
         exp = UINT64_C(0xc5c9c53e4804481c);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 1);
         exp = UINT64_C(0xc8bc47fcc63ec599);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
#endif
}
void dotests_2977() {
#if __ARM_NEON_FP16_INTRINSICS

{
   {
      float16x8_t arg1;
      int64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"reinterpret\", fnname = \"vreinterpretq_s64_f16\", rettype = \"int64x2_t\", argtypes = \"[float16x8_t]\", vals = [VectorVal [FloatVal 1.8101908568308929,FloatVal 7.930519497267923,FloatVal (-1.3865707950667456),FloatVal (-2.4079824205845686),FloatVal 3.251977900658037,FloatVal (-5.603766056620502),FloatVal (-5.871836996805994),FloatVal 2.967454718903257]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_f16(vcreate_f16(UINT64_C(0xc0d0bd8b47ee3f3d)),
                          vcreate_f16(UINT64_C(0x41efc5dfc59a4281)));
      clear_neon_saturated();
      //  Expect: "result" = 41efc5dfc59a4281c0d0bd8b47ee3f3d
      result = vreinterpretq_s64_f16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 0);
         exp = UINT64_C(0xc0d0bd8b47ee3f3d);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 1);
         exp = UINT64_C(0x41efc5dfc59a4281);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
#endif
}
void dotests_2978() {

{
   {
      int8x8_t arg1;
      int8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"not\", fnname = \"vmvn_s8\", rettype = \"int8x8_t\", argtypes = \"[int8x8_t]\", vals = [VectorVal [IntegerVal (-1),IntegerVal 20,IntegerVal (-128),IntegerVal 0,IntegerVal 127,IntegerVal (-1),IntegerVal 127,IntegerVal 118]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s8(UINT64_C(0x767fff7f008014ff));
      clear_neon_saturated();
      //  Expect: "result" = 89800080ff7feb00
      result = vmvn_s8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s8(result), 0);
      exp = UINT64_C(0x89800080ff7feb00);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2979() {

{
   {
      int16x4_t arg1;
      int16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"not\", fnname = \"vmvn_s16\", rettype = \"int16x4_t\", argtypes = \"[int16x4_t]\", vals = [VectorVal [IntegerVal 0,IntegerVal 32767,IntegerVal (-1),IntegerVal 32767]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s16(UINT64_C(0x7fffffff7fff0000));
      clear_neon_saturated();
      //  Expect: "result" = 800000008000ffff
      result = vmvn_s16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s16(result), 0);
      exp = UINT64_C(0x800000008000ffff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2980() {

{
   {
      int32x2_t arg1;
      int32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"not\", fnname = \"vmvn_s32\", rettype = \"int32x2_t\", argtypes = \"[int32x2_t]\", vals = [VectorVal [IntegerVal (-1),IntegerVal (-2147450881)]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s32(UINT64_C(0x80007fffffffffff));
      clear_neon_saturated();
      //  Expect: "result" = 7fff800000000000
      result = vmvn_s32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s32(result), 0);
      exp = UINT64_C(0x7fff800000000000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2981() {

{
   {
      uint8x8_t arg1;
      uint8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"not\", fnname = \"vmvn_u8\", rettype = \"uint8x8_t\", argtypes = \"[uint8x8_t]\", vals = [VectorVal [IntegerVal 128,IntegerVal 127,IntegerVal 175,IntegerVal 128,IntegerVal 255,IntegerVal 0,IntegerVal 0,IntegerVal 128]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u8(UINT64_C(0x800000ff80af7f80));
      clear_neon_saturated();
      //  Expect: "result" = 7fffff007f50807f
      result = vmvn_u8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u8(result), 0);
      exp = UINT64_C(0x7fffff007f50807f);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2982() {

{
   {
      uint16x4_t arg1;
      uint16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"not\", fnname = \"vmvn_u16\", rettype = \"uint16x4_t\", argtypes = \"[uint16x4_t]\", vals = [VectorVal [IntegerVal 32768,IntegerVal 0,IntegerVal 32768,IntegerVal 32768]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u16(UINT64_C(0x8000800000008000));
      clear_neon_saturated();
      //  Expect: "result" = 7fff7fffffff7fff
      result = vmvn_u16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u16(result), 0);
      exp = UINT64_C(0x7fff7fffffff7fff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2983() {

{
   {
      uint32x2_t arg1;
      uint32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"not\", fnname = \"vmvn_u32\", rettype = \"uint32x2_t\", argtypes = \"[uint32x2_t]\", vals = [VectorVal [IntegerVal 2147450880,IntegerVal 65535]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u32(UINT64_C(0x0000ffff7fff8000));
      clear_neon_saturated();
      //  Expect: "result" = ffff000080007fff
      result = vmvn_u32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u32(result), 0);
      exp = UINT64_C(0xffff000080007fff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2984() {

{
   {
      poly8x8_t arg1;
      poly8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"not\", fnname = \"vmvn_p8\", rettype = \"poly8x8_t\", argtypes = \"[poly8x8_t]\", vals = [VectorVal [PolyVal [0,0,0,1,1,1,1,0],PolyVal [1,0,1,1,1,0,1,1],PolyVal [0,1,0,1,1,1,0,1],PolyVal [0,1,1,0,0,1,1,1],PolyVal [1,1,1,0,1,0,1,0],PolyVal [1,0,1,1,1,1,0,1],PolyVal [1,1,0,0,1,1,0,1],PolyVal [0,0,1,0,1,0,1,0]]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_p8(UINT64_C(0x54b3bd57e6badd78));
      clear_neon_saturated();
      //  Expect: "result" = ab4c42a819452287
      result = vmvn_p8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_p8(result), 0);
      exp = UINT64_C(0xab4c42a819452287);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2985() {

{
   {
      int8x16_t arg1;
      int8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"not\", fnname = \"vmvnq_s8\", rettype = \"int8x16_t\", argtypes = \"[int8x16_t]\", vals = [VectorVal [IntegerVal 0,IntegerVal (-1),IntegerVal 118,IntegerVal (-1),IntegerVal (-128),IntegerVal (-1),IntegerVal (-128),IntegerVal (-1),IntegerVal (-128),IntegerVal (-128),IntegerVal 0,IntegerVal 127,IntegerVal (-1),IntegerVal (-128),IntegerVal (-1),IntegerVal 0]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s8(vcreate_s8(UINT64_C(0xff80ff80ff76ff00)),
                         vcreate_s8(UINT64_C(0x00ff80ff7f008080)));
      clear_neon_saturated();
      //  Expect: "result" = ff007f0080ff7f7f007f007f008900ff
      result = vmvnq_s8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result), 0);
         exp = UINT64_C(0x007f007f008900ff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result), 1);
         exp = UINT64_C(0xff007f0080ff7f7f);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2986() {

{
   {
      int16x8_t arg1;
      int16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"not\", fnname = \"vmvnq_s16\", rettype = \"int16x8_t\", argtypes = \"[int16x8_t]\", vals = [VectorVal [IntegerVal 12584,IntegerVal 29016,IntegerVal 32767,IntegerVal 0,IntegerVal (-1),IntegerVal (-32768),IntegerVal (-32768),IntegerVal 14174]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s16(vcreate_s16(UINT64_C(0x00007fff71583128)),
                          vcreate_s16(UINT64_C(0x375e80008000ffff)));
      clear_neon_saturated();
      //  Expect: "result" = c8a17fff7fff0000ffff80008ea7ced7
      result = vmvnq_s16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 0);
         exp = UINT64_C(0xffff80008ea7ced7);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 1);
         exp = UINT64_C(0xc8a17fff7fff0000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2987() {

{
   {
      int32x4_t arg1;
      int32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"not\", fnname = \"vmvnq_s32\", rettype = \"int32x4_t\", argtypes = \"[int32x4_t]\", vals = [VectorVal [IntegerVal 28781,IntegerVal 2147450880,IntegerVal (-69500928),IntegerVal 989134848]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s32(vcreate_s32(UINT64_C(0x7fff80000000706d)),
                          vcreate_s32(UINT64_C(0x3af50000fbdb8000)));
      clear_neon_saturated();
      //  Expect: "result" = c50affff04247fff80007fffffff8f92
      result = vmvnq_s32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 0);
         exp = UINT64_C(0x80007fffffff8f92);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 1);
         exp = UINT64_C(0xc50affff04247fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2988() {

{
   {
      uint8x16_t arg1;
      uint8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"not\", fnname = \"vmvnq_u8\", rettype = \"uint8x16_t\", argtypes = \"[uint8x16_t]\", vals = [VectorVal [IntegerVal 127,IntegerVal 216,IntegerVal 255,IntegerVal 128,IntegerVal 128,IntegerVal 127,IntegerVal 0,IntegerVal 121,IntegerVal 127,IntegerVal 0,IntegerVal 0,IntegerVal 127,IntegerVal 255,IntegerVal 255,IntegerVal 241,IntegerVal 0]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u8(vcreate_u8(UINT64_C(0x79007f8080ffd87f)),
                         vcreate_u8(UINT64_C(0x00f1ffff7f00007f)));
      clear_neon_saturated();
      //  Expect: "result" = ff0e000080ffff8086ff807f7f002780
      result = vmvnq_u8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 0);
         exp = UINT64_C(0x86ff807f7f002780);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 1);
         exp = UINT64_C(0xff0e000080ffff80);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2989() {

{
   {
      uint16x8_t arg1;
      uint16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"not\", fnname = \"vmvnq_u16\", rettype = \"uint16x8_t\", argtypes = \"[uint16x8_t]\", vals = [VectorVal [IntegerVal 19645,IntegerVal 0,IntegerVal 65535,IntegerVal 65535,IntegerVal 35459,IntegerVal 65535,IntegerVal 63452,IntegerVal 36993]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u16(vcreate_u16(UINT64_C(0xffffffff00004cbd)),
                          vcreate_u16(UINT64_C(0x9081f7dcffff8a83)));
      clear_neon_saturated();
      //  Expect: "result" = 6f7e08230000757c00000000ffffb342
      result = vmvnq_u16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 0);
         exp = UINT64_C(0x00000000ffffb342);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 1);
         exp = UINT64_C(0x6f7e08230000757c);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2990() {

{
   {
      uint32x4_t arg1;
      uint32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"not\", fnname = \"vmvnq_u32\", rettype = \"uint32x4_t\", argtypes = \"[uint32x4_t]\", vals = [VectorVal [IntegerVal 4294934527,IntegerVal 2147445439,IntegerVal 2147549183,IntegerVal 769556479]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u32(vcreate_u32(UINT64_C(0x7fff6abfffff7fff)),
                          vcreate_u32(UINT64_C(0x2dde7fff8000ffff)));
      clear_neon_saturated();
      //  Expect: "result" = d22180007fff00008000954000008000
      result = vmvnq_u32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 0);
         exp = UINT64_C(0x8000954000008000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 1);
         exp = UINT64_C(0xd22180007fff0000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2991() {

{
   {
      poly8x16_t arg1;
      poly8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"not\", fnname = \"vmvnq_p8\", rettype = \"poly8x16_t\", argtypes = \"[poly8x16_t]\", vals = [VectorVal [PolyVal [1,0,1,0,0,0,1,0],PolyVal [0,1,0,1,0,1,1,1],PolyVal [1,0,1,1,0,1,1,0],PolyVal [0,1,1,0,0,0,0,0],PolyVal [1,1,1,0,0,0,0,0],PolyVal [1,0,1,1,0,0,1,0],PolyVal [1,0,0,0,1,0,1,1],PolyVal [0,0,1,1,1,1,0,0],PolyVal [0,0,0,1,0,0,0,1],PolyVal [0,0,0,1,1,1,1,0],PolyVal [1,1,1,0,0,0,0,1],PolyVal [1,1,0,0,0,1,1,0],PolyVal [0,0,1,1,1,0,1,1],PolyVal [1,0,1,0,0,1,1,1],PolyVal [0,0,1,0,0,0,0,1],PolyVal [0,1,0,0,1,0,0,1]]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_p8(vcreate_p8(UINT64_C(0x3cd14d07066dea45)),
                         vcreate_p8(UINT64_C(0x9284e5dc63877888)));
      clear_neon_saturated();
      //  Expect: "result" = 6d7b1a239c788777c32eb2f8f99215ba
      result = vmvnq_p8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p8(result), 0);
         exp = UINT64_C(0xc32eb2f8f99215ba);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p8(result), 1);
         exp = UINT64_C(0x6d7b1a239c788777);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_2992() {

{
   {
      int8x8_t arg1;
      int8x8_t arg2;
      int8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"and\", fnname = \"vand_s8\", rettype = \"int8x8_t\", argtypes = \"[int8x8_t,int8x8_t]\", vals = [VectorVal [IntegerVal (-128),IntegerVal 0,IntegerVal (-128),IntegerVal (-1),IntegerVal (-1),IntegerVal 0,IntegerVal 73,IntegerVal 127],VectorVal [IntegerVal 0,IntegerVal 127,IntegerVal 127,IntegerVal (-128),IntegerVal 0,IntegerVal 0,IntegerVal (-128),IntegerVal (-128)]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s8(UINT64_C(0x7f4900ffff800080));
      arg2 = vcreate_s8(UINT64_C(0x80800000807f7f00));
      clear_neon_saturated();
      //  Expect: "result" = 0000000080000000
      result = vand_s8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s8(result), 0);
      exp = UINT64_C(0x0000000080000000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2993() {

{
   {
      int16x4_t arg1;
      int16x4_t arg2;
      int16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"and\", fnname = \"vand_s16\", rettype = \"int16x4_t\", argtypes = \"[int16x4_t,int16x4_t]\", vals = [VectorVal [IntegerVal 0,IntegerVal 32767,IntegerVal 11375,IntegerVal (-32768)],VectorVal [IntegerVal (-32768),IntegerVal 0,IntegerVal (-32768),IntegerVal (-1)]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s16(UINT64_C(0x80002c6f7fff0000));
      arg2 = vcreate_s16(UINT64_C(0xffff800000008000));
      clear_neon_saturated();
      //  Expect: "result" = 8000000000000000
      result = vand_s16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s16(result), 0);
      exp = UINT64_C(0x8000000000000000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2994() {

{
   {
      int32x2_t arg1;
      int32x2_t arg2;
      int32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"and\", fnname = \"vand_s32\", rettype = \"int32x2_t\", argtypes = \"[int32x2_t,int32x2_t]\", vals = [VectorVal [IntegerVal 1574312768,IntegerVal 2147418112],VectorVal [IntegerVal (-2147450881),IntegerVal 0]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s32(UINT64_C(0x7fff00005dd61b40));
      arg2 = vcreate_s32(UINT64_C(0x0000000080007fff));
      clear_neon_saturated();
      //  Expect: "result" = 0000000000001b40
      result = vand_s32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s32(result), 0);
      exp = UINT64_C(0x0000000000001b40);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2995() {

{
   {
      int64x1_t arg1;
      int64x1_t arg2;
      int64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"and\", fnname = \"vand_s64\", rettype = \"int64x1_t\", argtypes = \"[int64x1_t,int64x1_t]\", vals = [VectorVal [IntegerVal 9223231297218904064],VectorVal [IntegerVal (-140737488319681)]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s64(UINT64_C(0x7fff7fff7fff8000));
      arg2 = vcreate_s64(UINT64_C(0xffff800000008b3f));
      clear_neon_saturated();
      //  Expect: "result" = 7fff000000008000
      result = vand_s64(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s64(result), 0);
      exp = UINT64_C(0x7fff000000008000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2996() {

{
   {
      uint8x8_t arg1;
      uint8x8_t arg2;
      uint8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"and\", fnname = \"vand_u8\", rettype = \"uint8x8_t\", argtypes = \"[uint8x8_t,uint8x8_t]\", vals = [VectorVal [IntegerVal 193,IntegerVal 128,IntegerVal 0,IntegerVal 128,IntegerVal 0,IntegerVal 254,IntegerVal 0,IntegerVal 0],VectorVal [IntegerVal 138,IntegerVal 127,IntegerVal 128,IntegerVal 127,IntegerVal 251,IntegerVal 127,IntegerVal 255,IntegerVal 0]], start_saturated = True}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u8(UINT64_C(0x0000fe00800080c1));
      arg2 = vcreate_u8(UINT64_C(0x00ff7ffb7f807f8a));
      set_neon_saturated();
      //  Expect: "result" = 00007e0000000080
      result = vand_u8(arg1, arg2);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u8(result), 0);
      exp = UINT64_C(0x00007e0000000080);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2997() {

{
   {
      uint16x4_t arg1;
      uint16x4_t arg2;
      uint16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"and\", fnname = \"vand_u16\", rettype = \"uint16x4_t\", argtypes = \"[uint16x4_t,uint16x4_t]\", vals = [VectorVal [IntegerVal 46349,IntegerVal 65535,IntegerVal 32768,IntegerVal 32767],VectorVal [IntegerVal 49198,IntegerVal 32768,IntegerVal 13886,IntegerVal 32767]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u16(UINT64_C(0x7fff8000ffffb50d));
      arg2 = vcreate_u16(UINT64_C(0x7fff363e8000c02e));
      clear_neon_saturated();
      //  Expect: "result" = 7fff00008000800c
      result = vand_u16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u16(result), 0);
      exp = UINT64_C(0x7fff00008000800c);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2998() {

{
   {
      uint32x2_t arg1;
      uint32x2_t arg2;
      uint32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"and\", fnname = \"vand_u32\", rettype = \"uint32x2_t\", argtypes = \"[uint32x2_t,uint32x2_t]\", vals = [VectorVal [IntegerVal 2147418112,IntegerVal 2147483647],VectorVal [IntegerVal 4294905511,IntegerVal 2147450879]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u32(UINT64_C(0x7fffffff7fff0000));
      arg2 = vcreate_u32(UINT64_C(0x7fff7fffffff0ea7));
      clear_neon_saturated();
      //  Expect: "result" = 7fff7fff7fff0000
      result = vand_u32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u32(result), 0);
      exp = UINT64_C(0x7fff7fff7fff0000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_2999() {

{
   {
      uint64x1_t arg1;
      uint64x1_t arg2;
      uint64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"and\", fnname = \"vand_u64\", rettype = \"uint64x1_t\", argtypes = \"[uint64x1_t,uint64x1_t]\", vals = [VectorVal [IntegerVal 9223372039002226688],VectorVal [IntegerVal 18446603338368712703]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u64(UINT64_C(0x800000007fff8000));
      arg2 = vcreate_u64(UINT64_C(0xffff800080007fff));
      clear_neon_saturated();
      //  Expect: "result" = 8000000000000000
      result = vand_u64(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(result, 0);
      exp = UINT64_C(0x8000000000000000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_3000() {

{
   {
      int8x16_t arg1;
      int8x16_t arg2;
      int8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"and\", fnname = \"vandq_s8\", rettype = \"int8x16_t\", argtypes = \"[int8x16_t,int8x16_t]\", vals = [VectorVal [IntegerVal 0,IntegerVal 127,IntegerVal 90,IntegerVal (-40),IntegerVal (-124),IntegerVal (-128),IntegerVal 0,IntegerVal 72,IntegerVal 0,IntegerVal 103,IntegerVal 127,IntegerVal 93,IntegerVal (-1),IntegerVal (-1),IntegerVal 127,IntegerVal (-1)],VectorVal [IntegerVal 0,IntegerVal 127,IntegerVal 0,IntegerVal (-1),IntegerVal 0,IntegerVal 127,IntegerVal (-1),IntegerVal (-1),IntegerVal 0,IntegerVal (-128),IntegerVal 127,IntegerVal 127,IntegerVal (-128),IntegerVal 127,IntegerVal (-3),IntegerVal 127]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s8(vcreate_s8(UINT64_C(0x48008084d85a7f00)),
                         vcreate_s8(UINT64_C(0xff7fffff5d7f6700)));
      arg2 = vcombine_s8(vcreate_s8(UINT64_C(0xffff7f00ff007f00)),
                         vcreate_s8(UINT64_C(0x7ffd7f807f7f8000)));
      clear_neon_saturated();
      //  Expect: "result" = 7f7d7f805d7f000048000000d8007f00
      result = vandq_s8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result), 0);
         exp = UINT64_C(0x48000000d8007f00);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result), 1);
         exp = UINT64_C(0x7f7d7f805d7f0000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_3001() {

{
   {
      int16x8_t arg1;
      int16x8_t arg2;
      int16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"and\", fnname = \"vandq_s16\", rettype = \"int16x8_t\", argtypes = \"[int16x8_t,int16x8_t]\", vals = [VectorVal [IntegerVal (-22995),IntegerVal (-7872),IntegerVal (-32768),IntegerVal 32767,IntegerVal 32767,IntegerVal 0,IntegerVal (-1),IntegerVal (-1)],VectorVal [IntegerVal (-32768),IntegerVal 0,IntegerVal 32767,IntegerVal 0,IntegerVal (-1),IntegerVal 32767,IntegerVal (-32768),IntegerVal 0]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s16(vcreate_s16(UINT64_C(0x7fff8000e140a62d)),
                          vcreate_s16(UINT64_C(0xffffffff00007fff)));
      arg2 = vcombine_s16(vcreate_s16(UINT64_C(0x00007fff00008000)),
                          vcreate_s16(UINT64_C(0x000080007fffffff)));
      clear_neon_saturated();
      //  Expect: "result" = 0000800000007fff0000000000008000
      result = vandq_s16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 0);
         exp = UINT64_C(0x0000000000008000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 1);
         exp = UINT64_C(0x0000800000007fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_3002() {

{
   {
      int32x4_t arg1;
      int32x4_t arg2;
      int32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"and\", fnname = \"vandq_s32\", rettype = \"int32x4_t\", argtypes = \"[int32x4_t,int32x4_t]\", vals = [VectorVal [IntegerVal 32768,IntegerVal 32767,IntegerVal (-57917),IntegerVal (-2147418113)],VectorVal [IntegerVal (-28839),IntegerVal (-2147450881),IntegerVal (-2147483648),IntegerVal (-47944)]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s32(vcreate_s32(UINT64_C(0x00007fff00008000)),
                          vcreate_s32(UINT64_C(0x8000ffffffff1dc3)));
      arg2 = vcombine_s32(vcreate_s32(UINT64_C(0x80007fffffff8f59)),
                          vcreate_s32(UINT64_C(0xffff44b880000000)));
      clear_neon_saturated();
      //  Expect: "result" = 800044b88000000000007fff00008000
      result = vandq_s32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 0);
         exp = UINT64_C(0x00007fff00008000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 1);
         exp = UINT64_C(0x800044b880000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_3003() {

{
   {
      int64x2_t arg1;
      int64x2_t arg2;
      int64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"and\", fnname = \"vandq_s64\", rettype = \"int64x2_t\", argtypes = \"[int64x2_t,int64x2_t]\", vals = [VectorVal [IntegerVal (-9223372032559821446),IntegerVal (-9223090564925915136)],VectorVal [IntegerVal 1878001044613431296,IntegerVal 281470681776127]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s64(vcreate_s64(UINT64_C(0x80000000ffffcd7a)),
                          vcreate_s64(UINT64_C(0x8000ffff4a558000)));
      arg2 = vcombine_s64(vcreate_s64(UINT64_C(0x1a0fffffffff0000)),
                          vcreate_s64(UINT64_C(0x0000ffff00007fff)));
      clear_neon_saturated();
      //  Expect: "result" = 0000ffff0000000000000000ffff0000
      result = vandq_s64(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 0);
         exp = UINT64_C(0x00000000ffff0000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 1);
         exp = UINT64_C(0x0000ffff00000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_3004() {

{
   {
      uint8x16_t arg1;
      uint8x16_t arg2;
      uint8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"and\", fnname = \"vandq_u8\", rettype = \"uint8x16_t\", argtypes = \"[uint8x16_t,uint8x16_t]\", vals = [VectorVal [IntegerVal 0,IntegerVal 0,IntegerVal 127,IntegerVal 133,IntegerVal 128,IntegerVal 0,IntegerVal 255,IntegerVal 128,IntegerVal 128,IntegerVal 0,IntegerVal 91,IntegerVal 128,IntegerVal 0,IntegerVal 0,IntegerVal 128,IntegerVal 255],VectorVal [IntegerVal 128,IntegerVal 255,IntegerVal 128,IntegerVal 255,IntegerVal 255,IntegerVal 128,IntegerVal 0,IntegerVal 98,IntegerVal 214,IntegerVal 19,IntegerVal 128,IntegerVal 128,IntegerVal 127,IntegerVal 127,IntegerVal 127,IntegerVal 128]], start_saturated = True}";
      int reported = 0;
      arg1 = vcombine_u8(vcreate_u8(UINT64_C(0x80ff0080857f0000)),
                         vcreate_u8(UINT64_C(0xff800000805b0080)));
      arg2 = vcombine_u8(vcreate_u8(UINT64_C(0x620080ffff80ff80)),
                         vcreate_u8(UINT64_C(0x807f7f7f808013d6)));
      set_neon_saturated();
      //  Expect: "result" = 80000000800000800000008085000000
      result = vandq_u8(arg1, arg2);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 0);
         exp = UINT64_C(0x0000008085000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 1);
         exp = UINT64_C(0x8000000080000080);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_3005() {

{
   {
      uint16x8_t arg1;
      uint16x8_t arg2;
      uint16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"and\", fnname = \"vandq_u16\", rettype = \"uint16x8_t\", argtypes = \"[uint16x8_t,uint16x8_t]\", vals = [VectorVal [IntegerVal 51529,IntegerVal 0,IntegerVal 32768,IntegerVal 65535,IntegerVal 0,IntegerVal 32768,IntegerVal 29541,IntegerVal 0],VectorVal [IntegerVal 21771,IntegerVal 65535,IntegerVal 32768,IntegerVal 0,IntegerVal 49931,IntegerVal 32767,IntegerVal 0,IntegerVal 32767]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u16(vcreate_u16(UINT64_C(0xffff80000000c949)),
                          vcreate_u16(UINT64_C(0x0000736580000000)));
      arg2 = vcombine_u16(vcreate_u16(UINT64_C(0x00008000ffff550b)),
                          vcreate_u16(UINT64_C(0x7fff00007fffc30b)));
      clear_neon_saturated();
      //  Expect: "result" = 00000000000000000000800000004109
      result = vandq_u16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 0);
         exp = UINT64_C(0x0000800000004109);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 1);
         exp = 0;
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_3006() {

{
   {
      uint32x4_t arg1;
      uint32x4_t arg2;
      uint32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"and\", fnname = \"vandq_u32\", rettype = \"uint32x4_t\", argtypes = \"[uint32x4_t,uint32x4_t]\", vals = [VectorVal [IntegerVal 4294906756,IntegerVal 65535,IntegerVal 1459519487,IntegerVal 22480],VectorVal [IntegerVal 3644194816,IntegerVal 32768,IntegerVal 4294934527,IntegerVal 4294934527]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u32(vcreate_u32(UINT64_C(0x0000ffffffff1384)),
                          vcreate_u32(UINT64_C(0x000057d056fe7fff)));
      arg2 = vcombine_u32(vcreate_u32(UINT64_C(0x00008000d9360000)),
                          vcreate_u32(UINT64_C(0xffff7fffffff7fff)));
      clear_neon_saturated();
      //  Expect: "result" = 000057d056fe7fff00008000d9360000
      result = vandq_u32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 0);
         exp = UINT64_C(0x00008000d9360000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 1);
         exp = UINT64_C(0x000057d056fe7fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_3007() {

{
   {
      uint64x2_t arg1;
      uint64x2_t arg2;
      uint64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"and\", fnname = \"vandq_u64\", rettype = \"uint64x2_t\", argtypes = \"[uint64x2_t,uint64x2_t]\", vals = [VectorVal [IntegerVal 9223284198331088896,IntegerVal 3619735601697226752],VectorVal [IntegerVal 9223638200919359488,IntegerVal 9223512773816156159]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u64(vcreate_u64(UINT64_C(0x7fffb01c7fff8000)),
                          vcreate_u64(UINT64_C(0x323be259ffff8000)));
      arg2 = vcombine_u64(vcreate_u64(UINT64_C(0x8000f21326858000)),
                          vcreate_u64(UINT64_C(0x80007fffe096ffff)));
      clear_neon_saturated();
      //  Expect: "result" = 00006259e09680000000b01026858000
      result = vandq_u64(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 0);
         exp = UINT64_C(0x0000b01026858000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 1);
         exp = UINT64_C(0x00006259e0968000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_3008() {

{
   {
      int8x8_t arg1;
      int8x8_t arg2;
      int8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"orr\", fnname = \"vorr_s8\", rettype = \"int8x8_t\", argtypes = \"[int8x8_t,int8x8_t]\", vals = [VectorVal [IntegerVal (-128),IntegerVal (-91),IntegerVal 0,IntegerVal 70,IntegerVal 127,IntegerVal (-1),IntegerVal 106,IntegerVal (-126)],VectorVal [IntegerVal (-1),IntegerVal 0,IntegerVal 127,IntegerVal (-128),IntegerVal (-39),IntegerVal (-116),IntegerVal (-1),IntegerVal 127]], start_saturated = True}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s8(UINT64_C(0x826aff7f4600a580));
      arg2 = vcreate_s8(UINT64_C(0x7fff8cd9807f00ff));
      set_neon_saturated();
      //  Expect: "result" = ffffffffc67fa5ff
      result = vorr_s8(arg1, arg2);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s8(result), 0);
      exp = UINT64_C(0xffffffffc67fa5ff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_3009() {

{
   {
      int16x4_t arg1;
      int16x4_t arg2;
      int16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"orr\", fnname = \"vorr_s16\", rettype = \"int16x4_t\", argtypes = \"[int16x4_t,int16x4_t]\", vals = [VectorVal [IntegerVal 32767,IntegerVal 0,IntegerVal 0,IntegerVal 0],VectorVal [IntegerVal (-32768),IntegerVal 32767,IntegerVal 0,IntegerVal 32767]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s16(UINT64_C(0x0000000000007fff));
      arg2 = vcreate_s16(UINT64_C(0x7fff00007fff8000));
      clear_neon_saturated();
      //  Expect: "result" = 7fff00007fffffff
      result = vorr_s16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s16(result), 0);
      exp = UINT64_C(0x7fff00007fffffff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_3010() {

{
   {
      int32x2_t arg1;
      int32x2_t arg2;
      int32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"orr\", fnname = \"vorr_s32\", rettype = \"int32x2_t\", argtypes = \"[int32x2_t,int32x2_t]\", vals = [VectorVal [IntegerVal (-1),IntegerVal (-2147452325)],VectorVal [IntegerVal 2147418112,IntegerVal (-2147435032)]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s32(UINT64_C(0x80007a5bffffffff));
      arg2 = vcreate_s32(UINT64_C(0x8000bde87fff0000));
      clear_neon_saturated();
      //  Expect: "result" = 8000fffbffffffff
      result = vorr_s32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s32(result), 0);
      exp = UINT64_C(0x8000fffbffffffff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_3011() {

{
   {
      int64x1_t arg1;
      int64x1_t arg2;
      int64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"orr\", fnname = \"vorr_s64\", rettype = \"int64x1_t\", argtypes = \"[int64x1_t,int64x1_t]\", vals = [VectorVal [IntegerVal (-576880641)],VectorVal [IntegerVal (-1342)]], start_saturated = True}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s64(UINT64_C(0xffffffffdd9d7fff));
      arg2 = vcreate_s64(UINT64_C(0xfffffffffffffac2));
      set_neon_saturated();
      //  Expect: "result" = ffffffffffffffff
      result = vorr_s64(arg1, arg2);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s64(result), 0);
      exp = UINT64_C(0xffffffffffffffff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_3012() {

{
   {
      uint8x8_t arg1;
      uint8x8_t arg2;
      uint8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"orr\", fnname = \"vorr_u8\", rettype = \"uint8x8_t\", argtypes = \"[uint8x8_t,uint8x8_t]\", vals = [VectorVal [IntegerVal 127,IntegerVal 128,IntegerVal 127,IntegerVal 127,IntegerVal 255,IntegerVal 236,IntegerVal 0,IntegerVal 255],VectorVal [IntegerVal 128,IntegerVal 0,IntegerVal 128,IntegerVal 121,IntegerVal 128,IntegerVal 127,IntegerVal 255,IntegerVal 128]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u8(UINT64_C(0xff00ecff7f7f807f));
      arg2 = vcreate_u8(UINT64_C(0x80ff7f8079800080));
      clear_neon_saturated();
      //  Expect: "result" = ffffffff7fff80ff
      result = vorr_u8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u8(result), 0);
      exp = UINT64_C(0xffffffff7fff80ff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_3013() {

{
   {
      uint16x4_t arg1;
      uint16x4_t arg2;
      uint16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"orr\", fnname = \"vorr_u16\", rettype = \"uint16x4_t\", argtypes = \"[uint16x4_t,uint16x4_t]\", vals = [VectorVal [IntegerVal 0,IntegerVal 32768,IntegerVal 65535,IntegerVal 32767],VectorVal [IntegerVal 9111,IntegerVal 32768,IntegerVal 32768,IntegerVal 32768]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u16(UINT64_C(0x7fffffff80000000));
      arg2 = vcreate_u16(UINT64_C(0x8000800080002397));
      clear_neon_saturated();
      //  Expect: "result" = ffffffff80002397
      result = vorr_u16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u16(result), 0);
      exp = UINT64_C(0xffffffff80002397);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_3014() {

{
   {
      uint32x2_t arg1;
      uint32x2_t arg2;
      uint32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"orr\", fnname = \"vorr_u32\", rettype = \"uint32x2_t\", argtypes = \"[uint32x2_t,uint32x2_t]\", vals = [VectorVal [IntegerVal 32768,IntegerVal 4294934528],VectorVal [IntegerVal 32768,IntegerVal 626622463]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u32(UINT64_C(0xffff800000008000));
      arg2 = vcreate_u32(UINT64_C(0x25597fff00008000));
      clear_neon_saturated();
      //  Expect: "result" = ffffffff00008000
      result = vorr_u32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u32(result), 0);
      exp = UINT64_C(0xffffffff00008000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_3015() {

{
   {
      uint64x1_t arg1;
      uint64x1_t arg2;
      uint64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"orr\", fnname = \"vorr_u64\", rettype = \"uint64x1_t\", argtypes = \"[uint64x1_t,uint64x1_t]\", vals = [VectorVal [IntegerVal 9223090564025581568],VectorVal [IntegerVal 9223372035840245760]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u64(UINT64_C(0x7fff000080008000));
      arg2 = vcreate_u64(UINT64_C(0x7fffffffc3878000));
      clear_neon_saturated();
      //  Expect: "result" = 7fffffffc3878000
      result = vorr_u64(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(result, 0);
      exp = UINT64_C(0x7fffffffc3878000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_3016() {

{
   {
      int8x16_t arg1;
      int8x16_t arg2;
      int8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"orr\", fnname = \"vorrq_s8\", rettype = \"int8x16_t\", argtypes = \"[int8x16_t,int8x16_t]\", vals = [VectorVal [IntegerVal 127,IntegerVal (-1),IntegerVal 117,IntegerVal 0,IntegerVal 0,IntegerVal (-60),IntegerVal 0,IntegerVal (-128),IntegerVal 0,IntegerVal 127,IntegerVal 0,IntegerVal (-1),IntegerVal (-1),IntegerVal 127,IntegerVal 127,IntegerVal (-128)],VectorVal [IntegerVal 0,IntegerVal 127,IntegerVal (-3),IntegerVal 127,IntegerVal (-128),IntegerVal (-30),IntegerVal (-79),IntegerVal (-85),IntegerVal (-1),IntegerVal 0,IntegerVal 9,IntegerVal (-1),IntegerVal (-128),IntegerVal 0,IntegerVal 0,IntegerVal (-128)]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s8(vcreate_s8(UINT64_C(0x8000c4000075ff7f)),
                         vcreate_s8(UINT64_C(0x807f7fffff007f00)));
      arg2 = vcombine_s8(vcreate_s8(UINT64_C(0xabb1e2807ffd7f00)),
                         vcreate_s8(UINT64_C(0x80000080ff0900ff)));
      clear_neon_saturated();
      //  Expect: "result" = 807f7fffff097fffabb1e6807ffdff7f
      result = vorrq_s8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result), 0);
         exp = UINT64_C(0xabb1e6807ffdff7f);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result), 1);
         exp = UINT64_C(0x807f7fffff097fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_3017() {

{
   {
      int16x8_t arg1;
      int16x8_t arg2;
      int16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"orr\", fnname = \"vorrq_s16\", rettype = \"int16x8_t\", argtypes = \"[int16x8_t,int16x8_t]\", vals = [VectorVal [IntegerVal 32767,IntegerVal (-32768),IntegerVal (-32768),IntegerVal 0,IntegerVal 13196,IntegerVal (-32768),IntegerVal (-1),IntegerVal (-22659)],VectorVal [IntegerVal (-32768),IntegerVal (-1),IntegerVal 8963,IntegerVal (-26128),IntegerVal (-10129),IntegerVal (-1),IntegerVal 0,IntegerVal 32767]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s16(vcreate_s16(UINT64_C(0x0000800080007fff)),
                          vcreate_s16(UINT64_C(0xa77dffff8000338c)));
      arg2 = vcombine_s16(vcreate_s16(UINT64_C(0x99f02303ffff8000)),
                          vcreate_s16(UINT64_C(0x7fff0000ffffd86f)));
      clear_neon_saturated();
      //  Expect: "result" = fffffffffffffbef99f0a303ffffffff
      result = vorrq_s16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 0);
         exp = UINT64_C(0x99f0a303ffffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 1);
         exp = UINT64_C(0xfffffffffffffbef);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_3018() {

{
   {
      int32x4_t arg1;
      int32x4_t arg2;
      int32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"orr\", fnname = \"vorrq_s32\", rettype = \"int32x4_t\", argtypes = \"[int32x4_t,int32x4_t]\", vals = [VectorVal [IntegerVal 51574,IntegerVal (-65536),IntegerVal 2147450879,IntegerVal 2147443041],VectorVal [IntegerVal (-2147418113),IntegerVal 2147462488,IntegerVal 65535,IntegerVal 64390]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s32(vcreate_s32(UINT64_C(0xffff00000000c976)),
                          vcreate_s32(UINT64_C(0x7fff61617fff7fff)));
      arg2 = vcombine_s32(vcreate_s32(UINT64_C(0x7fffad588000ffff)),
                          vcreate_s32(UINT64_C(0x0000fb860000ffff)));
      clear_neon_saturated();
      //  Expect: "result" = 7ffffbe77fffffffffffad588000ffff
      result = vorrq_s32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 0);
         exp = UINT64_C(0xffffad588000ffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 1);
         exp = UINT64_C(0x7ffffbe77fffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_3019() {

{
   {
      int64x2_t arg1;
      int64x2_t arg2;
      int64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"orr\", fnname = \"vorrq_s64\", rettype = \"int64x2_t\", argtypes = \"[int64x2_t,int64x2_t]\", vals = [VectorVal [IntegerVal 9223372032559841279,IntegerVal 9223231302643187712],VectorVal [IntegerVal 1736700608452165632,IntegerVal 281472829208529]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s64(vcreate_s64(UINT64_C(0x7fffffff00007fff)),
                          vcreate_s64(UINT64_C(0x7fff8000c34f8000)));
      arg2 = vcombine_s64(vcreate_s64(UINT64_C(0x181a00007fff0000)),
                          vcreate_s64(UINT64_C(0x0000ffff7fffb7d1)));
      clear_neon_saturated();
      //  Expect: "result" = 7fffffffffffb7d17fffffff7fff7fff
      result = vorrq_s64(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 0);
         exp = UINT64_C(0x7fffffff7fff7fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 1);
         exp = UINT64_C(0x7fffffffffffb7d1);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_3020() {

{
   {
      uint8x16_t arg1;
      uint8x16_t arg2;
      uint8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"orr\", fnname = \"vorrq_u8\", rettype = \"uint8x16_t\", argtypes = \"[uint8x16_t,uint8x16_t]\", vals = [VectorVal [IntegerVal 128,IntegerVal 127,IntegerVal 128,IntegerVal 128,IntegerVal 0,IntegerVal 55,IntegerVal 127,IntegerVal 36,IntegerVal 255,IntegerVal 128,IntegerVal 0,IntegerVal 0,IntegerVal 127,IntegerVal 128,IntegerVal 128,IntegerVal 255],VectorVal [IntegerVal 255,IntegerVal 127,IntegerVal 128,IntegerVal 128,IntegerVal 255,IntegerVal 128,IntegerVal 255,IntegerVal 128,IntegerVal 127,IntegerVal 0,IntegerVal 213,IntegerVal 128,IntegerVal 128,IntegerVal 127,IntegerVal 127,IntegerVal 128]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u8(vcreate_u8(UINT64_C(0x247f370080807f80)),
                         vcreate_u8(UINT64_C(0xff80807f000080ff)));
      arg2 = vcombine_u8(vcreate_u8(UINT64_C(0x80ff80ff80807fff)),
                         vcreate_u8(UINT64_C(0x807f7f8080d5007f)));
      clear_neon_saturated();
      //  Expect: "result" = ffffffff80d580ffa4ffb7ff80807fff
      result = vorrq_u8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 0);
         exp = UINT64_C(0xa4ffb7ff80807fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 1);
         exp = UINT64_C(0xffffffff80d580ff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_3021() {

{
   {
      uint16x8_t arg1;
      uint16x8_t arg2;
      uint16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"orr\", fnname = \"vorrq_u16\", rettype = \"uint16x8_t\", argtypes = \"[uint16x8_t,uint16x8_t]\", vals = [VectorVal [IntegerVal 32768,IntegerVal 0,IntegerVal 32767,IntegerVal 65535,IntegerVal 32768,IntegerVal 65535,IntegerVal 65535,IntegerVal 0],VectorVal [IntegerVal 65535,IntegerVal 65535,IntegerVal 6377,IntegerVal 9307,IntegerVal 1524,IntegerVal 0,IntegerVal 0,IntegerVal 32768]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u16(vcreate_u16(UINT64_C(0xffff7fff00008000)),
                          vcreate_u16(UINT64_C(0x0000ffffffff8000)));
      arg2 = vcombine_u16(vcreate_u16(UINT64_C(0x245b18e9ffffffff)),
                          vcreate_u16(UINT64_C(0x80000000000005f4)));
      clear_neon_saturated();
      //  Expect: "result" = 8000ffffffff85f4ffff7fffffffffff
      result = vorrq_u16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 0);
         exp = UINT64_C(0xffff7fffffffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 1);
         exp = UINT64_C(0x8000ffffffff85f4);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_3022() {

{
   {
      uint32x4_t arg1;
      uint32x4_t arg2;
      uint32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"orr\", fnname = \"vorrq_u32\", rettype = \"uint32x4_t\", argtypes = \"[uint32x4_t,uint32x4_t]\", vals = [VectorVal [IntegerVal 4294932077,IntegerVal 2791211007,IntegerVal 2147516415,IntegerVal 0],VectorVal [IntegerVal 4294934528,IntegerVal 2147450879,IntegerVal 2147483647,IntegerVal 44157]], start_saturated = True}";
      int reported = 0;
      arg1 = vcombine_u32(vcreate_u32(UINT64_C(0xa65e7fffffff766d)),
                          vcreate_u32(UINT64_C(0x0000000080007fff)));
      arg2 = vcombine_u32(vcreate_u32(UINT64_C(0x7fff7fffffff8000)),
                          vcreate_u32(UINT64_C(0x0000ac7d7fffffff)));
      set_neon_saturated();
      //  Expect: "result" = 0000ac7dffffffffffff7ffffffff66d
      result = vorrq_u32(arg1, arg2);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 0);
         exp = UINT64_C(0xffff7ffffffff66d);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 1);
         exp = UINT64_C(0x0000ac7dffffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_3023() {

{
   {
      uint64x2_t arg1;
      uint64x2_t arg2;
      uint64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"orr\", fnname = \"vorrq_u64\", rettype = \"uint64x2_t\", argtypes = \"[uint64x2_t,uint64x2_t]\", vals = [VectorVal [IntegerVal 14832323897451108894,IntegerVal 6506748623055716352],VectorVal [IntegerVal 2692317183,IntegerVal 140734002331647]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u64(vcreate_u64(UINT64_C(0xcdd6ffffed1c5a1e)),
                          vcreate_u64(UINT64_C(0x5a4c9d65ffff8000)));
      arg2 = vcombine_u64(vcreate_u64(UINT64_C(0x00000000a0797fff)),
                          vcreate_u64(UINT64_C(0x00007fff30377fff)));
      clear_neon_saturated();
      //  Expect: "result" = 5a4cffffffffffffcdd6ffffed7d7fff
      result = vorrq_u64(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 0);
         exp = UINT64_C(0xcdd6ffffed7d7fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 1);
         exp = UINT64_C(0x5a4cffffffffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_3024() {

{
   {
      int8x8_t arg1;
      int8x8_t arg2;
      int8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"eor\", fnname = \"veor_s8\", rettype = \"int8x8_t\", argtypes = \"[int8x8_t,int8x8_t]\", vals = [VectorVal [IntegerVal (-128),IntegerVal 0,IntegerVal 0,IntegerVal (-128),IntegerVal 0,IntegerVal (-1),IntegerVal 0,IntegerVal (-100)],VectorVal [IntegerVal 58,IntegerVal (-1),IntegerVal 0,IntegerVal (-1),IntegerVal 127,IntegerVal (-11),IntegerVal 127,IntegerVal 0]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s8(UINT64_C(0x9c00ff0080000080));
      arg2 = vcreate_s8(UINT64_C(0x007ff57fff00ff3a));
      clear_neon_saturated();
      //  Expect: "result" = 9c7f0a7f7f00ffba
      result = veor_s8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s8(result), 0);
      exp = UINT64_C(0x9c7f0a7f7f00ffba);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_3025() {

{
   {
      int16x4_t arg1;
      int16x4_t arg2;
      int16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"eor\", fnname = \"veor_s16\", rettype = \"int16x4_t\", argtypes = \"[int16x4_t,int16x4_t]\", vals = [VectorVal [IntegerVal (-1),IntegerVal 0,IntegerVal 0,IntegerVal (-1)],VectorVal [IntegerVal 0,IntegerVal 32767,IntegerVal (-32768),IntegerVal (-32768)]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s16(UINT64_C(0xffff00000000ffff));
      arg2 = vcreate_s16(UINT64_C(0x800080007fff0000));
      clear_neon_saturated();
      //  Expect: "result" = 7fff80007fffffff
      result = veor_s16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s16(result), 0);
      exp = UINT64_C(0x7fff80007fffffff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_3026() {

{
   {
      int32x2_t arg1;
      int32x2_t arg2;
      int32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"eor\", fnname = \"veor_s32\", rettype = \"int32x2_t\", argtypes = \"[int32x2_t,int32x2_t]\", vals = [VectorVal [IntegerVal (-1630109696),IntegerVal 32767],VectorVal [IntegerVal (-2147450880),IntegerVal 32768]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s32(UINT64_C(0x00007fff9ed68000));
      arg2 = vcreate_s32(UINT64_C(0x0000800080008000));
      clear_neon_saturated();
      //  Expect: "result" = 0000ffff1ed60000
      result = veor_s32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s32(result), 0);
      exp = UINT64_C(0x0000ffff1ed60000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_3027() {

{
   {
      int64x1_t arg1;
      int64x1_t arg2;
      int64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"eor\", fnname = \"veor_s64\", rettype = \"int64x1_t\", argtypes = \"[int64x1_t,int64x1_t]\", vals = [VectorVal [IntegerVal 140735340904447],VectorVal [IntegerVal 4235289455566553087]], start_saturated = True}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s64(UINT64_C(0x00007fff80007fff));
      arg2 = vcreate_s64(UINT64_C(0x3ac6c55200007fff));
      set_neon_saturated();
      //  Expect: "result" = 3ac6baad80000000
      result = veor_s64(arg1, arg2);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s64(result), 0);
      exp = UINT64_C(0x3ac6baad80000000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_3028() {

{
   {
      uint8x8_t arg1;
      uint8x8_t arg2;
      uint8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"eor\", fnname = \"veor_u8\", rettype = \"uint8x8_t\", argtypes = \"[uint8x8_t,uint8x8_t]\", vals = [VectorVal [IntegerVal 128,IntegerVal 0,IntegerVal 224,IntegerVal 0,IntegerVal 0,IntegerVal 255,IntegerVal 113,IntegerVal 0],VectorVal [IntegerVal 128,IntegerVal 255,IntegerVal 128,IntegerVal 128,IntegerVal 0,IntegerVal 128,IntegerVal 0,IntegerVal 0]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u8(UINT64_C(0x0071ff0000e00080));
      arg2 = vcreate_u8(UINT64_C(0x000080008080ff80));
      clear_neon_saturated();
      //  Expect: "result" = 00717f008060ff00
      result = veor_u8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u8(result), 0);
      exp = UINT64_C(0x00717f008060ff00);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_3029() {

{
   {
      uint16x4_t arg1;
      uint16x4_t arg2;
      uint16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"eor\", fnname = \"veor_u16\", rettype = \"uint16x4_t\", argtypes = \"[uint16x4_t,uint16x4_t]\", vals = [VectorVal [IntegerVal 32767,IntegerVal 24088,IntegerVal 65535,IntegerVal 51531],VectorVal [IntegerVal 65535,IntegerVal 0,IntegerVal 65535,IntegerVal 19216]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u16(UINT64_C(0xc94bffff5e187fff));
      arg2 = vcreate_u16(UINT64_C(0x4b10ffff0000ffff));
      clear_neon_saturated();
      //  Expect: "result" = 825b00005e188000
      result = veor_u16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u16(result), 0);
      exp = UINT64_C(0x825b00005e188000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_3030() {

{
   {
      uint32x2_t arg1;
      uint32x2_t arg2;
      uint32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"eor\", fnname = \"veor_u32\", rettype = \"uint32x2_t\", argtypes = \"[uint32x2_t,uint32x2_t]\", vals = [VectorVal [IntegerVal 2147450879,IntegerVal 4294934527],VectorVal [IntegerVal 216236031,IntegerVal 2147516416]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u32(UINT64_C(0xffff7fff7fff7fff));
      arg2 = vcreate_u32(UINT64_C(0x800080000ce37fff));
      clear_neon_saturated();
      //  Expect: "result" = 7fffffff731c0000
      result = veor_u32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u32(result), 0);
      exp = UINT64_C(0x7fffffff731c0000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_3031() {

{
   {
      uint64x1_t arg1;
      uint64x1_t arg2;
      uint64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"eor\", fnname = \"veor_u64\", rettype = \"uint64x1_t\", argtypes = \"[uint64x1_t,uint64x1_t]\", vals = [VectorVal [IntegerVal 9223653509684067303],VectorVal [IntegerVal 252530485559295]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u64(UINT64_C(0x8000ffff8000fbe7));
      arg2 = vcreate_u64(UINT64_C(0x0000e5acd5e2ffff));
      clear_neon_saturated();
      //  Expect: "result" = 80001a5355e20418
      result = veor_u64(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(result, 0);
      exp = UINT64_C(0x80001a5355e20418);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_3032() {

{
   {
      int8x16_t arg1;
      int8x16_t arg2;
      int8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"eor\", fnname = \"veorq_s8\", rettype = \"int8x16_t\", argtypes = \"[int8x16_t,int8x16_t]\", vals = [VectorVal [IntegerVal (-1),IntegerVal 59,IntegerVal 127,IntegerVal 0,IntegerVal (-128),IntegerVal 83,IntegerVal 127,IntegerVal 0,IntegerVal (-91),IntegerVal 0,IntegerVal 95,IntegerVal (-81),IntegerVal 119,IntegerVal (-96),IntegerVal (-128),IntegerVal (-1)],VectorVal [IntegerVal (-1),IntegerVal (-1),IntegerVal 0,IntegerVal (-9),IntegerVal 127,IntegerVal 24,IntegerVal (-128),IntegerVal 127,IntegerVal 78,IntegerVal (-128),IntegerVal 127,IntegerVal (-12),IntegerVal (-1),IntegerVal (-114),IntegerVal (-1),IntegerVal 127]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s8(vcreate_s8(UINT64_C(0x007f5380007f3bff)),
                         vcreate_s8(UINT64_C(0xff80a077af5f00a5)));
      arg2 = vcombine_s8(vcreate_s8(UINT64_C(0x7f80187ff700ffff)),
                         vcreate_s8(UINT64_C(0x7fff8efff47f804e)));
      clear_neon_saturated();
      //  Expect: "result" = 807f2e885b2080eb7fff4bfff77fc400
      result = veorq_s8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result), 0);
         exp = UINT64_C(0x7fff4bfff77fc400);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result), 1);
         exp = UINT64_C(0x807f2e885b2080eb);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_3033() {

{
   {
      int16x8_t arg1;
      int16x8_t arg2;
      int16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"eor\", fnname = \"veorq_s16\", rettype = \"int16x8_t\", argtypes = \"[int16x8_t,int16x8_t]\", vals = [VectorVal [IntegerVal 32767,IntegerVal 18568,IntegerVal (-1),IntegerVal 32767,IntegerVal (-30068),IntegerVal (-32768),IntegerVal 0,IntegerVal 0],VectorVal [IntegerVal 23239,IntegerVal (-1),IntegerVal (-1),IntegerVal (-32768),IntegerVal 0,IntegerVal (-32768),IntegerVal (-1),IntegerVal 7091]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s16(vcreate_s16(UINT64_C(0x7fffffff48887fff)),
                          vcreate_s16(UINT64_C(0x0000000080008a8c)));
      arg2 = vcombine_s16(vcreate_s16(UINT64_C(0x8000ffffffff5ac7)),
                          vcreate_s16(UINT64_C(0x1bb3ffff80000000)));
      clear_neon_saturated();
      //  Expect: "result" = 1bb3ffff00008a8cffff0000b7772538
      result = veorq_s16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 0);
         exp = UINT64_C(0xffff0000b7772538);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 1);
         exp = UINT64_C(0x1bb3ffff00008a8c);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_3034() {

{
   {
      int32x4_t arg1;
      int32x4_t arg2;
      int32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"eor\", fnname = \"veorq_s32\", rettype = \"int32x4_t\", argtypes = \"[int32x4_t,int32x4_t]\", vals = [VectorVal [IntegerVal (-2147418113),IntegerVal 399605759,IntegerVal 0,IntegerVal (-2147418113)],VectorVal [IntegerVal (-32769),IntegerVal (-65536),IntegerVal 0,IntegerVal 2147455738]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s32(vcreate_s32(UINT64_C(0x17d17fff8000ffff)),
                          vcreate_s32(UINT64_C(0x8000ffff00000000)));
      arg2 = vcombine_s32(vcreate_s32(UINT64_C(0xffff0000ffff7fff)),
                          vcreate_s32(UINT64_C(0x7fff92fa00000000)));
      clear_neon_saturated();
      //  Expect: "result" = ffff6d0500000000e82e7fff7fff8000
      result = veorq_s32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 0);
         exp = UINT64_C(0xe82e7fff7fff8000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 1);
         exp = UINT64_C(0xffff6d0500000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_3035() {

{
   {
      int64x2_t arg1;
      int64x2_t arg2;
      int64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"eor\", fnname = \"veorq_s64\", rettype = \"int64x2_t\", argtypes = \"[int64x2_t,int64x2_t]\", vals = [VectorVal [IntegerVal 281474550936051,IntegerVal (-5355483642237828801)],VectorVal [IntegerVal 661325455634205355,IntegerVal 9223112489833616126]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s64(vcreate_s64(UINT64_C(0x0000ffffe69f31f3)),
                          vcreate_s64(UINT64_C(0xb5ad80007fffc13f)));
      arg2 = vcombine_s64(vcreate_s64(UINT64_C(0x092d7fff80000aab)),
                          vcreate_s64(UINT64_C(0x7fff13f1800052fe)));
      clear_neon_saturated();
      //  Expect: "result" = ca5293f1ffff93c1092d8000669f3b58
      result = veorq_s64(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 0);
         exp = UINT64_C(0x092d8000669f3b58);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 1);
         exp = UINT64_C(0xca5293f1ffff93c1);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_3036() {

{
   {
      uint8x16_t arg1;
      uint8x16_t arg2;
      uint8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"eor\", fnname = \"veorq_u8\", rettype = \"uint8x16_t\", argtypes = \"[uint8x16_t,uint8x16_t]\", vals = [VectorVal [IntegerVal 127,IntegerVal 255,IntegerVal 128,IntegerVal 128,IntegerVal 224,IntegerVal 255,IntegerVal 127,IntegerVal 255,IntegerVal 127,IntegerVal 128,IntegerVal 127,IntegerVal 128,IntegerVal 128,IntegerVal 127,IntegerVal 128,IntegerVal 0],VectorVal [IntegerVal 255,IntegerVal 128,IntegerVal 161,IntegerVal 0,IntegerVal 128,IntegerVal 187,IntegerVal 132,IntegerVal 127,IntegerVal 132,IntegerVal 128,IntegerVal 0,IntegerVal 0,IntegerVal 244,IntegerVal 255,IntegerVal 127,IntegerVal 128]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u8(vcreate_u8(UINT64_C(0xff7fffe08080ff7f)),
                         vcreate_u8(UINT64_C(0x00807f80807f807f)));
      arg2 = vcombine_u8(vcreate_u8(UINT64_C(0x7f84bb8000a180ff)),
                         vcreate_u8(UINT64_C(0x807ffff400008084)));
      clear_neon_saturated();
      //  Expect: "result" = 80ff8074807f00fb80fb446080217f80
      result = veorq_u8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 0);
         exp = UINT64_C(0x80fb446080217f80);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 1);
         exp = UINT64_C(0x80ff8074807f00fb);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_3037() {

{
   {
      uint16x8_t arg1;
      uint16x8_t arg2;
      uint16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"eor\", fnname = \"veorq_u16\", rettype = \"uint16x8_t\", argtypes = \"[uint16x8_t,uint16x8_t]\", vals = [VectorVal [IntegerVal 21556,IntegerVal 8409,IntegerVal 59844,IntegerVal 32767,IntegerVal 32767,IntegerVal 32767,IntegerVal 65535,IntegerVal 32768],VectorVal [IntegerVal 13374,IntegerVal 0,IntegerVal 32767,IntegerVal 0,IntegerVal 32768,IntegerVal 32767,IntegerVal 0,IntegerVal 32767]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u16(vcreate_u16(UINT64_C(0x7fffe9c420d95434)),
                          vcreate_u16(UINT64_C(0x8000ffff7fff7fff)));
      arg2 = vcombine_u16(vcreate_u16(UINT64_C(0x00007fff0000343e)),
                          vcreate_u16(UINT64_C(0x7fff00007fff8000)));
      clear_neon_saturated();
      //  Expect: "result" = ffffffff0000ffff7fff963b20d9600a
      result = veorq_u16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 0);
         exp = UINT64_C(0x7fff963b20d9600a);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 1);
         exp = UINT64_C(0xffffffff0000ffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_3038() {

{
   {
      uint32x4_t arg1;
      uint32x4_t arg2;
      uint32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"eor\", fnname = \"veorq_u32\", rettype = \"uint32x4_t\", argtypes = \"[uint32x4_t,uint32x4_t]\", vals = [VectorVal [IntegerVal 33010,IntegerVal 2147545568,IntegerVal 3298295808,IntegerVal 1539276799],VectorVal [IntegerVal 32768,IntegerVal 2147483647,IntegerVal 2147450879,IntegerVal 2147483647]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u32(vcreate_u32(UINT64_C(0x8000f1e0000080f2)),
                          vcreate_u32(UINT64_C(0x5bbf7fffc4980000)));
      arg2 = vcombine_u32(vcreate_u32(UINT64_C(0x7fffffff00008000)),
                          vcreate_u32(UINT64_C(0x7fffffff7fff7fff)));
      clear_neon_saturated();
      //  Expect: "result" = 24408000bb677fffffff0e1f000000f2
      result = veorq_u32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 0);
         exp = UINT64_C(0xffff0e1f000000f2);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 1);
         exp = UINT64_C(0x24408000bb677fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_3039() {

{
   {
      uint64x2_t arg1;
      uint64x2_t arg2;
      uint64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"eor\", fnname = \"veorq_u64\", rettype = \"uint64x2_t\", argtypes = \"[uint64x2_t,uint64x2_t]\", vals = [VectorVal [IntegerVal 9223201580340251002,IntegerVal 212794154647552],VectorVal [IntegerVal 18446583972361207807,IntegerVal 140735340904448]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u64(vcreate_u64(UINT64_C(0x7fff64f88000897a)),
                          vcreate_u64(UINT64_C(0x0000c188ffff8000)));
      arg2 = vcombine_u64(vcreate_u64(UINT64_C(0xffff6e638000ffff)),
                          vcreate_u64(UINT64_C(0x00007fff80008000)));
      clear_neon_saturated();
      //  Expect: "result" = 0000be777fff000080000a9b00007685
      result = veorq_u64(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 0);
         exp = UINT64_C(0x80000a9b00007685);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 1);
         exp = UINT64_C(0x0000be777fff0000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_3040() {

{
   {
      int8x8_t arg1;
      int8x8_t arg2;
      int8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"bic\", fnname = \"vbic_s8\", rettype = \"int8x8_t\", argtypes = \"[int8x8_t,int8x8_t]\", vals = [VectorVal [IntegerVal (-86),IntegerVal (-128),IntegerVal (-102),IntegerVal (-128),IntegerVal (-17),IntegerVal 0,IntegerVal (-128),IntegerVal 127],VectorVal [IntegerVal (-1),IntegerVal 66,IntegerVal (-128),IntegerVal (-128),IntegerVal (-92),IntegerVal 0,IntegerVal 0,IntegerVal 127]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s8(UINT64_C(0x7f8000ef809a80aa));
      arg2 = vcreate_s8(UINT64_C(0x7f0000a4808042ff));
      clear_neon_saturated();
      //  Expect: "result" = 0080004b001a8000
      result = vbic_s8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s8(result), 0);
      exp = UINT64_C(0x0080004b001a8000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_3041() {

{
   {
      int16x4_t arg1;
      int16x4_t arg2;
      int16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"bic\", fnname = \"vbic_s16\", rettype = \"int16x4_t\", argtypes = \"[int16x4_t,int16x4_t]\", vals = [VectorVal [IntegerVal 1984,IntegerVal (-1),IntegerVal (-32768),IntegerVal 32767],VectorVal [IntegerVal (-32768),IntegerVal 32767,IntegerVal (-32768),IntegerVal (-32768)]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s16(UINT64_C(0x7fff8000ffff07c0));
      arg2 = vcreate_s16(UINT64_C(0x800080007fff8000));
      clear_neon_saturated();
      //  Expect: "result" = 7fff0000800007c0
      result = vbic_s16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s16(result), 0);
      exp = UINT64_C(0x7fff0000800007c0);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_3042() {

{
   {
      int32x2_t arg1;
      int32x2_t arg2;
      int32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"bic\", fnname = \"vbic_s32\", rettype = \"int32x2_t\", argtypes = \"[int32x2_t,int32x2_t]\", vals = [VectorVal [IntegerVal (-2147483648),IntegerVal 49021],VectorVal [IntegerVal 940539904,IntegerVal (-32768)]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s32(UINT64_C(0x0000bf7d80000000));
      arg2 = vcreate_s32(UINT64_C(0xffff8000380f8000));
      clear_neon_saturated();
      //  Expect: "result" = 00003f7d80000000
      result = vbic_s32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s32(result), 0);
      exp = UINT64_C(0x00003f7d80000000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_3043() {

{
   {
      int64x1_t arg1;
      int64x1_t arg2;
      int64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"bic\", fnname = \"vbic_s64\", rettype = \"int64x1_t\", argtypes = \"[int64x1_t,int64x1_t]\", vals = [VectorVal [IntegerVal 140735340871679],VectorVal [IntegerVal 140734950211584]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s64(UINT64_C(0x00007fff7fffffff));
      arg2 = vcreate_s64(UINT64_C(0x00007fff68b70000));
      clear_neon_saturated();
      //  Expect: "result" = 000000001748ffff
      result = vbic_s64(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s64(result), 0);
      exp = UINT64_C(0x000000001748ffff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_3044() {

{
   {
      uint8x8_t arg1;
      uint8x8_t arg2;
      uint8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"bic\", fnname = \"vbic_u8\", rettype = \"uint8x8_t\", argtypes = \"[uint8x8_t,uint8x8_t]\", vals = [VectorVal [IntegerVal 139,IntegerVal 0,IntegerVal 127,IntegerVal 179,IntegerVal 157,IntegerVal 255,IntegerVal 239,IntegerVal 127],VectorVal [IntegerVal 0,IntegerVal 255,IntegerVal 255,IntegerVal 128,IntegerVal 255,IntegerVal 127,IntegerVal 255,IntegerVal 0]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u8(UINT64_C(0x7fefff9db37f008b));
      arg2 = vcreate_u8(UINT64_C(0x00ff7fff80ffff00));
      clear_neon_saturated();
      //  Expect: "result" = 7f0080003300008b
      result = vbic_u8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u8(result), 0);
      exp = UINT64_C(0x7f0080003300008b);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_3045() {

{
   {
      uint16x4_t arg1;
      uint16x4_t arg2;
      uint16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"bic\", fnname = \"vbic_u16\", rettype = \"uint16x4_t\", argtypes = \"[uint16x4_t,uint16x4_t]\", vals = [VectorVal [IntegerVal 0,IntegerVal 27285,IntegerVal 0,IntegerVal 61420],VectorVal [IntegerVal 24035,IntegerVal 0,IntegerVal 65535,IntegerVal 0]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u16(UINT64_C(0xefec00006a950000));
      arg2 = vcreate_u16(UINT64_C(0x0000ffff00005de3));
      clear_neon_saturated();
      //  Expect: "result" = efec00006a950000
      result = vbic_u16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u16(result), 0);
      exp = UINT64_C(0xefec00006a950000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_3046() {

{
   {
      uint32x2_t arg1;
      uint32x2_t arg2;
      uint32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"bic\", fnname = \"vbic_u32\", rettype = \"uint32x2_t\", argtypes = \"[uint32x2_t,uint32x2_t]\", vals = [VectorVal [IntegerVal 2983329792,IntegerVal 2147418112],VectorVal [IntegerVal 2147483647,IntegerVal 2147549183]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u32(UINT64_C(0x7fff0000b1d20000));
      arg2 = vcreate_u32(UINT64_C(0x8000ffff7fffffff));
      clear_neon_saturated();
      //  Expect: "result" = 7fff000080000000
      result = vbic_u32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u32(result), 0);
      exp = UINT64_C(0x7fff000080000000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_3047() {

{
   {
      uint64x1_t arg1;
      uint64x1_t arg2;
      uint64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"bic\", fnname = \"vbic_u64\", rettype = \"uint64x1_t\", argtypes = \"[uint64x1_t,uint64x1_t]\", vals = [VectorVal [IntegerVal 9223372034707357695],VectorVal [IntegerVal 8082131745371970957]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u64(UINT64_C(0x7fffffff8000ffff));
      arg2 = vcreate_u64(UINT64_C(0x702980005ecddd8d));
      clear_neon_saturated();
      //  Expect: "result" = 0fd67fff80002272
      result = vbic_u64(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(result, 0);
      exp = UINT64_C(0x0fd67fff80002272);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_3048() {

{
   {
      int8x16_t arg1;
      int8x16_t arg2;
      int8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"bic\", fnname = \"vbicq_s8\", rettype = \"int8x16_t\", argtypes = \"[int8x16_t,int8x16_t]\", vals = [VectorVal [IntegerVal (-21),IntegerVal 79,IntegerVal (-128),IntegerVal 0,IntegerVal 0,IntegerVal (-128),IntegerVal (-128),IntegerVal 45,IntegerVal (-39),IntegerVal (-62),IntegerVal 0,IntegerVal (-128),IntegerVal 0,IntegerVal 0,IntegerVal (-20),IntegerVal (-128)],VectorVal [IntegerVal (-128),IntegerVal 127,IntegerVal 0,IntegerVal (-128),IntegerVal (-128),IntegerVal (-128),IntegerVal 127,IntegerVal (-128),IntegerVal (-1),IntegerVal 0,IntegerVal (-67),IntegerVal (-9),IntegerVal (-128),IntegerVal (-26),IntegerVal (-99),IntegerVal (-128)]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s8(vcreate_s8(UINT64_C(0x2d80800000804feb)),
                         vcreate_s8(UINT64_C(0x80ec00008000c2d9)));
      arg2 = vcombine_s8(vcreate_s8(UINT64_C(0x807f808080007f80)),
                         vcreate_s8(UINT64_C(0x809de680f7bd00ff)));
      clear_neon_saturated();
      //  Expect: "result" = 006000000000c2002d8000000080006b
      result = vbicq_s8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result), 0);
         exp = UINT64_C(0x2d8000000080006b);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result), 1);
         exp = UINT64_C(0x006000000000c200);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_3049() {

{
   {
      int16x8_t arg1;
      int16x8_t arg2;
      int16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"bic\", fnname = \"vbicq_s16\", rettype = \"int16x8_t\", argtypes = \"[int16x8_t,int16x8_t]\", vals = [VectorVal [IntegerVal (-1),IntegerVal 0,IntegerVal (-1),IntegerVal (-10),IntegerVal (-32768),IntegerVal 0,IntegerVal 32767,IntegerVal (-7899)],VectorVal [IntegerVal 32767,IntegerVal (-32768),IntegerVal 0,IntegerVal (-32768),IntegerVal 32767,IntegerVal 32767,IntegerVal (-32768),IntegerVal 32109]], start_saturated = True}";
      int reported = 0;
      arg1 = vcombine_s16(vcreate_s16(UINT64_C(0xfff6ffff0000ffff)),
                          vcreate_s16(UINT64_C(0xe1257fff00008000)));
      arg2 = vcombine_s16(vcreate_s16(UINT64_C(0x8000000080007fff)),
                          vcreate_s16(UINT64_C(0x7d6d80007fff7fff)));
      set_neon_saturated();
      //  Expect: "result" = 80007fff000080007ff6ffff00008000
      result = vbicq_s16(arg1, arg2);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 0);
         exp = UINT64_C(0x7ff6ffff00008000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 1);
         exp = UINT64_C(0x80007fff00008000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_3050() {

{
   {
      int32x4_t arg1;
      int32x4_t arg2;
      int32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"bic\", fnname = \"vbicq_s32\", rettype = \"int32x4_t\", argtypes = \"[int32x4_t,int32x4_t]\", vals = [VectorVal [IntegerVal 2139652096,IntegerVal 2147450880,IntegerVal (-2147450881),IntegerVal 2147450879],VectorVal [IntegerVal (-2147418113),IntegerVal (-65536),IntegerVal (-587595776),IntegerVal (-41550)]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s32(vcreate_s32(UINT64_C(0x7fff80007f888000)),
                          vcreate_s32(UINT64_C(0x7fff7fff80007fff)));
      arg2 = vcombine_s32(vcreate_s32(UINT64_C(0xffff00008000ffff)),
                          vcreate_s32(UINT64_C(0xffff5db2dcfa0000)));
      clear_neon_saturated();
      //  Expect: "result" = 0000224d00007fff000080007f880000
      result = vbicq_s32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 0);
         exp = UINT64_C(0x000080007f880000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 1);
         exp = UINT64_C(0x0000224d00007fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_3051() {

{
   {
      int64x2_t arg1;
      int64x2_t arg2;
      int64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"bic\", fnname = \"vbicq_s64\", rettype = \"int64x2_t\", argtypes = \"[int64x2_t,int64x2_t]\", vals = [VectorVal [IntegerVal (-9223231301513904128),IntegerVal (-8746975640919474177)],VectorVal [IntegerVal 9223262740674478079,IntegerVal 140735340904447]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s64(vcreate_s64(UINT64_C(0x80007fff80000000)),
                          vcreate_s64(UINT64_C(0x869c7fff7fffffff)));
      arg2 = vcombine_s64(vcreate_s64(UINT64_C(0x7fff9c987fff7fff)),
                          vcreate_s64(UINT64_C(0x00007fff80007fff)));
      clear_neon_saturated();
      //  Expect: "result" = 869c00007fff80008000636780000000
      result = vbicq_s64(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 0);
         exp = UINT64_C(0x8000636780000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 1);
         exp = UINT64_C(0x869c00007fff8000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_3052() {

{
   {
      uint8x16_t arg1;
      uint8x16_t arg2;
      uint8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"bic\", fnname = \"vbicq_u8\", rettype = \"uint8x16_t\", argtypes = \"[uint8x16_t,uint8x16_t]\", vals = [VectorVal [IntegerVal 0,IntegerVal 127,IntegerVal 0,IntegerVal 155,IntegerVal 124,IntegerVal 127,IntegerVal 127,IntegerVal 10,IntegerVal 127,IntegerVal 128,IntegerVal 127,IntegerVal 0,IntegerVal 128,IntegerVal 0,IntegerVal 177,IntegerVal 127],VectorVal [IntegerVal 160,IntegerVal 20,IntegerVal 0,IntegerVal 176,IntegerVal 128,IntegerVal 255,IntegerVal 0,IntegerVal 0,IntegerVal 0,IntegerVal 255,IntegerVal 0,IntegerVal 0,IntegerVal 127,IntegerVal 0,IntegerVal 127,IntegerVal 127]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u8(vcreate_u8(UINT64_C(0x0a7f7f7c9b007f00)),
                         vcreate_u8(UINT64_C(0x7fb10080007f807f)));
      arg2 = vcombine_u8(vcreate_u8(UINT64_C(0x0000ff80b00014a0)),
                         vcreate_u8(UINT64_C(0x7f7f007f0000ff00)));
      clear_neon_saturated();
      //  Expect: "result" = 00800080007f007f0a7f007c0b006b00
      result = vbicq_u8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 0);
         exp = UINT64_C(0x0a7f007c0b006b00);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 1);
         exp = UINT64_C(0x00800080007f007f);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_3053() {

{
   {
      uint16x8_t arg1;
      uint16x8_t arg2;
      uint16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"bic\", fnname = \"vbicq_u16\", rettype = \"uint16x8_t\", argtypes = \"[uint16x8_t,uint16x8_t]\", vals = [VectorVal [IntegerVal 32768,IntegerVal 65535,IntegerVal 32767,IntegerVal 32767,IntegerVal 32768,IntegerVal 0,IntegerVal 32767,IntegerVal 31042],VectorVal [IntegerVal 0,IntegerVal 32767,IntegerVal 32768,IntegerVal 32768,IntegerVal 32768,IntegerVal 35841,IntegerVal 21911,IntegerVal 0]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u16(vcreate_u16(UINT64_C(0x7fff7fffffff8000)),
                          vcreate_u16(UINT64_C(0x79427fff00008000)));
      arg2 = vcombine_u16(vcreate_u16(UINT64_C(0x800080007fff0000)),
                          vcreate_u16(UINT64_C(0x000055978c018000)));
      clear_neon_saturated();
      //  Expect: "result" = 79422a68000000007fff7fff80008000
      result = vbicq_u16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 0);
         exp = UINT64_C(0x7fff7fff80008000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 1);
         exp = UINT64_C(0x79422a6800000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_3054() {

{
   {
      uint32x4_t arg1;
      uint32x4_t arg2;
      uint32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"bic\", fnname = \"vbicq_u32\", rettype = \"uint32x4_t\", argtypes = \"[uint32x4_t,uint32x4_t]\", vals = [VectorVal [IntegerVal 2147549183,IntegerVal 2147549183,IntegerVal 2147483648,IntegerVal 32768],VectorVal [IntegerVal 32768,IntegerVal 2147483648,IntegerVal 1622742941,IntegerVal 2147516416]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u32(vcreate_u32(UINT64_C(0x8000ffff8000ffff)),
                          vcreate_u32(UINT64_C(0x0000800080000000)));
      arg2 = vcombine_u32(vcreate_u32(UINT64_C(0x8000000000008000)),
                          vcreate_u32(UINT64_C(0x8000800060b9179d)));
      clear_neon_saturated();
      //  Expect: "result" = 00000000800000000000ffff80007fff
      result = vbicq_u32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 0);
         exp = UINT64_C(0x0000ffff80007fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 1);
         exp = UINT64_C(0x0000000080000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_3055() {

{
   {
      uint64x2_t arg1;
      uint64x2_t arg2;
      uint64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"bic\", fnname = \"vbicq_u64\", rettype = \"uint64x2_t\", argtypes = \"[uint64x2_t,uint64x2_t]\", vals = [VectorVal [IntegerVal 9223512776577581055,IntegerVal 18446689948531687424],VectorVal [IntegerVal 9223379853695320063,IntegerVal 9223372036854775807]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u64(vcreate_u64(UINT64_C(0x80008000852effff)),
                          vcreate_u64(UINT64_C(0xffffcec600000000)));
      arg2 = vcombine_u64(vcreate_u64(UINT64_C(0x8000071c0000ffff)),
                          vcreate_u64(UINT64_C(0x7fffffffffffffff)));
      clear_neon_saturated();
      //  Expect: "result" = 800000000000000000008000852e0000
      result = vbicq_u64(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 0);
         exp = UINT64_C(0x00008000852e0000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 1);
         exp = UINT64_C(0x8000000000000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_3056() {

{
   {
      int8x8_t arg1;
      int8x8_t arg2;
      int8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"orn\", fnname = \"vorn_s8\", rettype = \"int8x8_t\", argtypes = \"[int8x8_t,int8x8_t]\", vals = [VectorVal [IntegerVal 99,IntegerVal 0,IntegerVal 0,IntegerVal 0,IntegerVal 116,IntegerVal (-1),IntegerVal (-128),IntegerVal (-128)],VectorVal [IntegerVal 0,IntegerVal (-1),IntegerVal 127,IntegerVal (-1),IntegerVal (-1),IntegerVal (-1),IntegerVal 0,IntegerVal 0]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s8(UINT64_C(0x8080ff7400000063));
      arg2 = vcreate_s8(UINT64_C(0x0000ffffff7fff00));
      clear_neon_saturated();
      //  Expect: "result" = ffffff74008000ff
      result = vorn_s8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s8(result), 0);
      exp = UINT64_C(0xffffff74008000ff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_3057() {

{
   {
      int16x4_t arg1;
      int16x4_t arg2;
      int16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"orn\", fnname = \"vorn_s16\", rettype = \"int16x4_t\", argtypes = \"[int16x4_t,int16x4_t]\", vals = [VectorVal [IntegerVal 32767,IntegerVal (-32768),IntegerVal (-32768),IntegerVal (-32768)],VectorVal [IntegerVal (-32768),IntegerVal (-1763),IntegerVal (-1),IntegerVal (-1)]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s16(UINT64_C(0x8000800080007fff));
      arg2 = vcreate_s16(UINT64_C(0xfffffffff91d8000));
      clear_neon_saturated();
      //  Expect: "result" = 8000800086e27fff
      result = vorn_s16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s16(result), 0);
      exp = UINT64_C(0x8000800086e27fff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_3058() {

{
   {
      int32x2_t arg1;
      int32x2_t arg2;
      int32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"orn\", fnname = \"vorn_s32\", rettype = \"int32x2_t\", argtypes = \"[int32x2_t,int32x2_t]\", vals = [VectorVal [IntegerVal (-303792129),IntegerVal 65535],VectorVal [IntegerVal (-2147418113),IntegerVal 2147418112]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s32(UINT64_C(0x0000ffffede47fff));
      arg2 = vcreate_s32(UINT64_C(0x7fff00008000ffff));
      clear_neon_saturated();
      //  Expect: "result" = 8000ffffffff7fff
      result = vorn_s32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s32(result), 0);
      exp = UINT64_C(0x8000ffffffff7fff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_3059() {

{
   {
      int64x1_t arg1;
      int64x1_t arg2;
      int64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"orn\", fnname = \"vorn_s64\", rettype = \"int64x1_t\", argtypes = \"[int64x1_t,int64x1_t]\", vals = [VectorVal [IntegerVal (-221828618452992)],VectorVal [IntegerVal (-140739635838977)]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s64(UINT64_C(0xffff363f7fff0000));
      arg2 = vcreate_s64(UINT64_C(0xffff7fff7fffffff));
      clear_neon_saturated();
      //  Expect: "result" = ffffb63fffff0000
      result = vorn_s64(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s64(result), 0);
      exp = UINT64_C(0xffffb63fffff0000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_3060() {

{
   {
      uint8x8_t arg1;
      uint8x8_t arg2;
      uint8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"orn\", fnname = \"vorn_u8\", rettype = \"uint8x8_t\", argtypes = \"[uint8x8_t,uint8x8_t]\", vals = [VectorVal [IntegerVal 255,IntegerVal 48,IntegerVal 114,IntegerVal 128,IntegerVal 128,IntegerVal 176,IntegerVal 128,IntegerVal 255],VectorVal [IntegerVal 127,IntegerVal 255,IntegerVal 255,IntegerVal 255,IntegerVal 222,IntegerVal 255,IntegerVal 0,IntegerVal 255]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u8(UINT64_C(0xff80b080807230ff));
      arg2 = vcreate_u8(UINT64_C(0xff00ffdeffffff7f));
      clear_neon_saturated();
      //  Expect: "result" = ffffb0a1807230ff
      result = vorn_u8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u8(result), 0);
      exp = UINT64_C(0xffffb0a1807230ff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_3061() {

{
   {
      uint16x4_t arg1;
      uint16x4_t arg2;
      uint16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"orn\", fnname = \"vorn_u16\", rettype = \"uint16x4_t\", argtypes = \"[uint16x4_t,uint16x4_t]\", vals = [VectorVal [IntegerVal 0,IntegerVal 65535,IntegerVal 63384,IntegerVal 32768],VectorVal [IntegerVal 65535,IntegerVal 51290,IntegerVal 0,IntegerVal 55671]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u16(UINT64_C(0x8000f798ffff0000));
      arg2 = vcreate_u16(UINT64_C(0xd9770000c85affff));
      clear_neon_saturated();
      //  Expect: "result" = a688ffffffff0000
      result = vorn_u16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u16(result), 0);
      exp = UINT64_C(0xa688ffffffff0000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_3062() {

{
   {
      uint32x2_t arg1;
      uint32x2_t arg2;
      uint32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"orn\", fnname = \"vorn_u32\", rettype = \"uint32x2_t\", argtypes = \"[uint32x2_t,uint32x2_t]\", vals = [VectorVal [IntegerVal 65535,IntegerVal 32767],VectorVal [IntegerVal 46673,IntegerVal 4294967295]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u32(UINT64_C(0x00007fff0000ffff));
      arg2 = vcreate_u32(UINT64_C(0xffffffff0000b651));
      clear_neon_saturated();
      //  Expect: "result" = 00007fffffffffff
      result = vorn_u32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u32(result), 0);
      exp = UINT64_C(0x00007fffffffffff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_3063() {

{
   {
      uint64x1_t arg1;
      uint64x1_t arg2;
      uint64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"orn\", fnname = \"vorn_u64\", rettype = \"uint64x1_t\", argtypes = \"[uint64x1_t,uint64x1_t]\", vals = [VectorVal [IntegerVal 18446531930242383871],VectorVal [IntegerVal 9223372039002292223]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u64(UINT64_C(0xffff3f0e7fff7fff));
      arg2 = vcreate_u64(UINT64_C(0x8000000080007fff));
      clear_neon_saturated();
      //  Expect: "result" = ffffffff7fffffff
      result = vorn_u64(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(result, 0);
      exp = UINT64_C(0xffffffff7fffffff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_3064() {

{
   {
      int8x16_t arg1;
      int8x16_t arg2;
      int8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"orn\", fnname = \"vornq_s8\", rettype = \"int8x16_t\", argtypes = \"[int8x16_t,int8x16_t]\", vals = [VectorVal [IntegerVal (-47),IntegerVal 0,IntegerVal 0,IntegerVal 127,IntegerVal 98,IntegerVal (-77),IntegerVal (-128),IntegerVal 0,IntegerVal (-1),IntegerVal (-128),IntegerVal 0,IntegerVal 127,IntegerVal (-128),IntegerVal 0,IntegerVal (-128),IntegerVal (-1)],VectorVal [IntegerVal (-32),IntegerVal (-1),IntegerVal 0,IntegerVal 127,IntegerVal 127,IntegerVal (-1),IntegerVal 0,IntegerVal 0,IntegerVal 0,IntegerVal (-128),IntegerVal 81,IntegerVal (-1),IntegerVal 127,IntegerVal (-127),IntegerVal 0,IntegerVal (-1)]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s8(vcreate_s8(UINT64_C(0x0080b3627f0000d1)),
                         vcreate_s8(UINT64_C(0xff8000807f0080ff)));
      arg2 = vcombine_s8(vcreate_s8(UINT64_C(0x0000ff7f7f00ffe0)),
                         vcreate_s8(UINT64_C(0xff00817fff518000)));
      clear_neon_saturated();
      //  Expect: "result" = ffff7e807faeffffffffb3e2ffff00df
      result = vornq_s8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result), 0);
         exp = UINT64_C(0xffffb3e2ffff00df);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result), 1);
         exp = UINT64_C(0xffff7e807faeffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_3065() {

{
   {
      int16x8_t arg1;
      int16x8_t arg2;
      int16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"orn\", fnname = \"vornq_s16\", rettype = \"int16x8_t\", argtypes = \"[int16x8_t,int16x8_t]\", vals = [VectorVal [IntegerVal 32767,IntegerVal 0,IntegerVal (-32768),IntegerVal 0,IntegerVal (-32768),IntegerVal (-1),IntegerVal 32767,IntegerVal (-32768)],VectorVal [IntegerVal 32767,IntegerVal 32767,IntegerVal (-1),IntegerVal (-1),IntegerVal (-10124),IntegerVal 32767,IntegerVal 0,IntegerVal 32767]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s16(vcreate_s16(UINT64_C(0x0000800000007fff)),
                          vcreate_s16(UINT64_C(0x80007fffffff8000)));
      arg2 = vcombine_s16(vcreate_s16(UINT64_C(0xffffffff7fff7fff)),
                          vcreate_s16(UINT64_C(0x7fff00007fffd874)));
      clear_neon_saturated();
      //  Expect: "result" = 8000ffffffffa78b000080008000ffff
      result = vornq_s16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 0);
         exp = UINT64_C(0x000080008000ffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 1);
         exp = UINT64_C(0x8000ffffffffa78b);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_3066() {

{
   {
      int32x4_t arg1;
      int32x4_t arg2;
      int32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"orn\", fnname = \"vornq_s32\", rettype = \"int32x4_t\", argtypes = \"[int32x4_t,int32x4_t]\", vals = [VectorVal [IntegerVal (-65536),IntegerVal (-2147450880),IntegerVal 0,IntegerVal 32768],VectorVal [IntegerVal (-32768),IntegerVal (-2147418113),IntegerVal (-2147450702),IntegerVal (-32768)]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s32(vcreate_s32(UINT64_C(0x80008000ffff0000)),
                          vcreate_s32(UINT64_C(0x0000800000000000)));
      arg2 = vcombine_s32(vcreate_s32(UINT64_C(0x8000ffffffff8000)),
                          vcreate_s32(UINT64_C(0xffff8000800080b2)));
      clear_neon_saturated();
      //  Expect: "result" = 0000ffff7fff7f4dffff8000ffff7fff
      result = vornq_s32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 0);
         exp = UINT64_C(0xffff8000ffff7fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 1);
         exp = UINT64_C(0x0000ffff7fff7f4d);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_3067() {

{
   {
      int64x2_t arg1;
      int64x2_t arg2;
      int64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"orn\", fnname = \"vornq_s64\", rettype = \"int64x2_t\", argtypes = \"[int64x2_t,int64x2_t]\", vals = [VectorVal [IntegerVal 6128836140065947648,IntegerVal 9223346327180574720],VectorVal [IntegerVal (-5905345007094628352),IntegerVal 2473742828526632960]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s64(vcreate_s64(UINT64_C(0x550dffff57350000)),
                          vcreate_s64(UINT64_C(0x7fffe89e00008000)));
      arg2 = vcombine_s64(vcreate_s64(UINT64_C(0xae0c0000ffff8000)),
                          vcreate_s64(UINT64_C(0x22547fff00000000)));
      clear_neon_saturated();
      //  Expect: "result" = ffffe89effffffff55ffffff57357fff
      result = vornq_s64(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 0);
         exp = UINT64_C(0x55ffffff57357fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 1);
         exp = UINT64_C(0xffffe89effffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_3068() {

{
   {
      uint8x16_t arg1;
      uint8x16_t arg2;
      uint8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"orn\", fnname = \"vornq_u8\", rettype = \"uint8x16_t\", argtypes = \"[uint8x16_t,uint8x16_t]\", vals = [VectorVal [IntegerVal 230,IntegerVal 128,IntegerVal 128,IntegerVal 255,IntegerVal 127,IntegerVal 255,IntegerVal 128,IntegerVal 0,IntegerVal 0,IntegerVal 127,IntegerVal 128,IntegerVal 88,IntegerVal 255,IntegerVal 255,IntegerVal 118,IntegerVal 128],VectorVal [IntegerVal 0,IntegerVal 127,IntegerVal 255,IntegerVal 0,IntegerVal 127,IntegerVal 0,IntegerVal 47,IntegerVal 128,IntegerVal 128,IntegerVal 128,IntegerVal 0,IntegerVal 255,IntegerVal 0,IntegerVal 127,IntegerVal 255,IntegerVal 255]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u8(vcreate_u8(UINT64_C(0x0080ff7fff8080e6)),
                         vcreate_u8(UINT64_C(0x8076ffff58807f00)));
      arg2 = vcombine_u8(vcreate_u8(UINT64_C(0x802f007f00ff7f00)),
                         vcreate_u8(UINT64_C(0xffff7f00ff008080)));
      clear_neon_saturated();
      //  Expect: "result" = 8076ffff58ff7f7f7fd0ffffff8080ff
      result = vornq_u8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 0);
         exp = UINT64_C(0x7fd0ffffff8080ff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 1);
         exp = UINT64_C(0x8076ffff58ff7f7f);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_3069() {

{
   {
      uint16x8_t arg1;
      uint16x8_t arg2;
      uint16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"orn\", fnname = \"vornq_u16\", rettype = \"uint16x8_t\", argtypes = \"[uint16x8_t,uint16x8_t]\", vals = [VectorVal [IntegerVal 6162,IntegerVal 32768,IntegerVal 32767,IntegerVal 0,IntegerVal 0,IntegerVal 32767,IntegerVal 33563,IntegerVal 0],VectorVal [IntegerVal 65535,IntegerVal 49003,IntegerVal 32768,IntegerVal 65535,IntegerVal 0,IntegerVal 0,IntegerVal 0,IntegerVal 28691]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u16(vcreate_u16(UINT64_C(0x00007fff80001812)),
                          vcreate_u16(UINT64_C(0x0000831b7fff0000)));
      arg2 = vcombine_u16(vcreate_u16(UINT64_C(0xffff8000bf6bffff)),
                          vcreate_u16(UINT64_C(0x7013000000000000)));
      clear_neon_saturated();
      //  Expect: "result" = 8fecffffffffffff00007fffc0941812
      result = vornq_u16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 0);
         exp = UINT64_C(0x00007fffc0941812);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 1);
         exp = UINT64_C(0x8fecffffffffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_3070() {

{
   {
      uint32x4_t arg1;
      uint32x4_t arg2;
      uint32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"orn\", fnname = \"vornq_u32\", rettype = \"uint32x4_t\", argtypes = \"[uint32x4_t,uint32x4_t]\", vals = [VectorVal [IntegerVal 2147516415,IntegerVal 4294901760,IntegerVal 4294901760,IntegerVal 32768],VectorVal [IntegerVal 4294934527,IntegerVal 2147483648,IntegerVal 2147509107,IntegerVal 2147516415]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u32(vcreate_u32(UINT64_C(0xffff000080007fff)),
                          vcreate_u32(UINT64_C(0x00008000ffff0000)));
      arg2 = vcombine_u32(vcreate_u32(UINT64_C(0x80000000ffff7fff)),
                          vcreate_u32(UINT64_C(0x80007fff80006373)));
      clear_neon_saturated();
      //  Expect: "result" = 7fff8000ffff9c8cffffffff8000ffff
      result = vornq_u32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 0);
         exp = UINT64_C(0xffffffff8000ffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 1);
         exp = UINT64_C(0x7fff8000ffff9c8c);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_3071() {

{
   {
      uint64x2_t arg1;
      uint64x2_t arg2;
      uint64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"orn\", fnname = \"vornq_u64\", rettype = \"uint64x2_t\", argtypes = \"[uint64x2_t,uint64x2_t]\", vals = [VectorVal [IntegerVal 7419398911116247039,IntegerVal 9223512776490647552],VectorVal [IntegerVal 18446603331926261760,IntegerVal 18446683759483813887]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u64(vcreate_u64(UINT64_C(0x66f700000000ffff)),
                          vcreate_u64(UINT64_C(0x8000800080008000)));
      arg2 = vcombine_u64(vcreate_u64(UINT64_C(0xffff7fff00008000)),
                          vcreate_u64(UINT64_C(0xffffc924ffffffff)));
      clear_neon_saturated();
      //  Expect: "result" = 8000b6db8000800066f78000ffffffff
      result = vornq_u64(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 0);
         exp = UINT64_C(0x66f78000ffffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 1);
         exp = UINT64_C(0x8000b6db80008000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_3072() {

{
   {
      uint8x8_t arg1;
      int8x8_t arg2;
      int8x8_t arg3;
      int8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"bsl\", fnname = \"vbsl_s8\", rettype = \"int8x8_t\", argtypes = \"[uint8x8_t,int8x8_t,int8x8_t]\", vals = [VectorVal [IntegerVal 128,IntegerVal 114,IntegerVal 159,IntegerVal 127,IntegerVal 163,IntegerVal 0,IntegerVal 128,IntegerVal 127],VectorVal [IntegerVal (-128),IntegerVal 0,IntegerVal 0,IntegerVal (-1),IntegerVal (-1),IntegerVal 0,IntegerVal 127,IntegerVal (-128)],VectorVal [IntegerVal (-69),IntegerVal (-1),IntegerVal 127,IntegerVal 0,IntegerVal (-128),IntegerVal 0,IntegerVal 0,IntegerVal 0]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u8(UINT64_C(0x7f8000a37f9f7280));
      arg2 = vcreate_s8(UINT64_C(0x807f00ffff000080));
      arg3 = vcreate_s8(UINT64_C(0x00000080007fffbb));
      clear_neon_saturated();
      //  Expect: "result" = 000000a37f608dbb
      result = vbsl_s8(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s8(result), 0);
      exp = UINT64_C(0x000000a37f608dbb);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_3073() {

{
   {
      uint16x4_t arg1;
      int16x4_t arg2;
      int16x4_t arg3;
      int16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"bsl\", fnname = \"vbsl_s16\", rettype = \"int16x4_t\", argtypes = \"[uint16x4_t,int16x4_t,int16x4_t]\", vals = [VectorVal [IntegerVal 32768,IntegerVal 0,IntegerVal 0,IntegerVal 65535],VectorVal [IntegerVal 32767,IntegerVal (-1),IntegerVal (-1),IntegerVal (-22150)],VectorVal [IntegerVal 0,IntegerVal 32767,IntegerVal (-1),IntegerVal 32767]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u16(UINT64_C(0xffff000000008000));
      arg2 = vcreate_s16(UINT64_C(0xa97affffffff7fff));
      arg3 = vcreate_s16(UINT64_C(0x7fffffff7fff0000));
      clear_neon_saturated();
      //  Expect: "result" = a97affff7fff0000
      result = vbsl_s16(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s16(result), 0);
      exp = UINT64_C(0xa97affff7fff0000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_3074() {

{
   {
      uint32x2_t arg1;
      int32x2_t arg2;
      int32x2_t arg3;
      int32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"bsl\", fnname = \"vbsl_s32\", rettype = \"int32x2_t\", argtypes = \"[uint32x2_t,int32x2_t,int32x2_t]\", vals = [VectorVal [IntegerVal 2147466948,IntegerVal 4294947866],VectorVal [IntegerVal (-2147483648),IntegerVal (-2147450880)],VectorVal [IntegerVal 2147483647,IntegerVal (-2147450881)]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u32(UINT64_C(0xffffb41a7fffbec4));
      arg2 = vcreate_s32(UINT64_C(0x8000800080000000));
      arg3 = vcreate_s32(UINT64_C(0x80007fff7fffffff));
      clear_neon_saturated();
      //  Expect: "result" = 8000cbe50000413b
      result = vbsl_s32(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s32(result), 0);
      exp = UINT64_C(0x8000cbe50000413b);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_3075() {

{
   {
      uint64x1_t arg1;
      int64x1_t arg2;
      int64x1_t arg3;
      int64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"bsl\", fnname = \"vbsl_s64\", rettype = \"int64x1_t\", argtypes = \"[uint64x1_t,int64x1_t,int64x1_t]\", vals = [VectorVal [IntegerVal 9223231297218969599],VectorVal [IntegerVal (-9223372036854775808)],VectorVal [IntegerVal 9223090561892024319]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u64(UINT64_C(0x7fff7fff80007fff));
      arg2 = vcreate_s64(UINT64_C(0x8000000000000000));
      arg3 = vcreate_s64(UINT64_C(0x7fff000000d4ffff));
      clear_neon_saturated();
      //  Expect: "result" = 0000000000d48000
      result = vbsl_s64(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s64(result), 0);
      exp = UINT64_C(0x0000000000d48000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_3076() {

{
   {
      uint8x8_t arg1;
      uint8x8_t arg2;
      uint8x8_t arg3;
      uint8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"bsl\", fnname = \"vbsl_u8\", rettype = \"uint8x8_t\", argtypes = \"[uint8x8_t,uint8x8_t,uint8x8_t]\", vals = [VectorVal [IntegerVal 128,IntegerVal 0,IntegerVal 127,IntegerVal 128,IntegerVal 127,IntegerVal 0,IntegerVal 255,IntegerVal 127],VectorVal [IntegerVal 0,IntegerVal 128,IntegerVal 255,IntegerVal 255,IntegerVal 96,IntegerVal 5,IntegerVal 127,IntegerVal 255],VectorVal [IntegerVal 255,IntegerVal 0,IntegerVal 95,IntegerVal 127,IntegerVal 0,IntegerVal 0,IntegerVal 128,IntegerVal 127]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u8(UINT64_C(0x7fff007f807f0080));
      arg2 = vcreate_u8(UINT64_C(0xff7f0560ffff8000));
      arg3 = vcreate_u8(UINT64_C(0x7f8000007f5f00ff));
      clear_neon_saturated();
      //  Expect: "result" = 7f7f0060ff7f007f
      result = vbsl_u8(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u8(result), 0);
      exp = UINT64_C(0x7f7f0060ff7f007f);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_3077() {

{
   {
      uint16x4_t arg1;
      uint16x4_t arg2;
      uint16x4_t arg3;
      uint16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"bsl\", fnname = \"vbsl_u16\", rettype = \"uint16x4_t\", argtypes = \"[uint16x4_t,uint16x4_t,uint16x4_t]\", vals = [VectorVal [IntegerVal 32767,IntegerVal 15649,IntegerVal 0,IntegerVal 0],VectorVal [IntegerVal 65535,IntegerVal 0,IntegerVal 65535,IntegerVal 26681],VectorVal [IntegerVal 65535,IntegerVal 6448,IntegerVal 32768,IntegerVal 65535]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u16(UINT64_C(0x000000003d217fff));
      arg2 = vcreate_u16(UINT64_C(0x6839ffff0000ffff));
      arg3 = vcreate_u16(UINT64_C(0xffff80001930ffff));
      clear_neon_saturated();
      //  Expect: "result" = ffff80000010ffff
      result = vbsl_u16(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u16(result), 0);
      exp = UINT64_C(0xffff80000010ffff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_3078() {

{
   {
      uint32x2_t arg1;
      uint32x2_t arg2;
      uint32x2_t arg3;
      uint32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"bsl\", fnname = \"vbsl_u32\", rettype = \"uint32x2_t\", argtypes = \"[uint32x2_t,uint32x2_t,uint32x2_t]\", vals = [VectorVal [IntegerVal 32768,IntegerVal 62383],VectorVal [IntegerVal 2147549183,IntegerVal 743688038],VectorVal [IntegerVal 4294934527,IntegerVal 1486225407]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u32(UINT64_C(0x0000f3af00008000));
      arg2 = vcreate_u32(UINT64_C(0x2c53c7668000ffff));
      arg3 = vcreate_u32(UINT64_C(0x5895ffffffff7fff));
      clear_neon_saturated();
      //  Expect: "result" = 5895cf76ffffffff
      result = vbsl_u32(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u32(result), 0);
      exp = UINT64_C(0x5895cf76ffffffff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_3079() {

{
   {
      uint64x1_t arg1;
      uint64x1_t arg2;
      uint64x1_t arg3;
      uint64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"bsl\", fnname = \"vbsl_u64\", rettype = \"uint64x1_t\", argtypes = \"[uint64x1_t,uint64x1_t,uint64x1_t]\", vals = [VectorVal [IntegerVal 140737488289792],VectorVal [IntegerVal 9223257595303667035],VectorVal [IntegerVal 2147418112]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u64(UINT64_C(0x00007fffffff0000));
      arg2 = vcreate_u64(UINT64_C(0x7fff97ea7fffa55b));
      arg3 = vcreate_u64(UINT64_C(0x000000007fff0000));
      clear_neon_saturated();
      //  Expect: "result" = 000017ea7fff0000
      result = vbsl_u64(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(result, 0);
      exp = UINT64_C(0x000017ea7fff0000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_3080() {

{
   {
      uint32x2_t arg1;
      float32x2_t arg2;
      float32x2_t arg3;
      float32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"bsl\", fnname = \"vbsl_f32\", rettype = \"float32x2_t\", argtypes = \"[uint32x2_t,float32x2_t,float32x2_t]\", vals = [VectorVal [IntegerVal 2147549183,IntegerVal 4049240064],VectorVal [FloatVal 0.8051517009735107,FloatVal 0.4334458112716675],VectorVal [FloatVal 0.8297564387321472,FloatVal 0.725365400314331]], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_u32(UINT64_C(0xf15a80008000ffff));
      arg2 = vcreate_f32(UINT64_C(0x3eddec9c3f4e1e6c));
      arg3 = vcreate_f32(UINT64_C(0x3f39b18c3f546aeb));
      clear_neon_saturated();
      //  Expect: "result" = 3e79b18c3f541e6c
      result = vbsl_f32(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result, 0);
         exp = ((float32_t) 0.8285892009735107);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result, 1);
         exp = ((float32_t) 0.24384135007858276);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
   }
}
}
void dotests_3081() {

{
   {
      uint8x8_t arg1;
      poly8x8_t arg2;
      poly8x8_t arg3;
      poly8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"bsl\", fnname = \"vbsl_p8\", rettype = \"poly8x8_t\", argtypes = \"[uint8x8_t,poly8x8_t,poly8x8_t]\", vals = [VectorVal [IntegerVal 0,IntegerVal 128,IntegerVal 128,IntegerVal 128,IntegerVal 0,IntegerVal 127,IntegerVal 0,IntegerVal 128],VectorVal [PolyVal [1,1,0,1,0,1,1,0],PolyVal [0,1,0,0,1,1,1,0],PolyVal [0,0,1,1,0,0,0,1],PolyVal [0,1,0,1,0,0,0,0],PolyVal [1,1,0,1,1,1,0,1],PolyVal [0,0,0,0,0,0,0,1],PolyVal [1,0,0,0,0,0,0,0],PolyVal [1,0,1,1,1,1,1,0]],VectorVal [PolyVal [1,1,0,1,0,0,1,0],PolyVal [1,0,1,0,1,0,1,0],PolyVal [0,0,0,0,0,0,0,1],PolyVal [0,1,0,0,0,1,0,0],PolyVal [1,0,1,0,0,1,0,0],PolyVal [1,1,1,0,0,0,1,0],PolyVal [1,0,1,1,0,1,0,0],PolyVal [0,0,0,0,0,1,0,1]]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u8(UINT64_C(0x80007f0080808000));
      arg2 = vcreate_p8(UINT64_C(0x7d0180bb0a8c726b));
      arg3 = vcreate_p8(UINT64_C(0xa02d47252280554b));
      clear_neon_saturated();
      //  Expect: "result" = 202d00252280554b
      result = vbsl_p8(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_p8(result), 0);
      exp = UINT64_C(0x202d00252280554b);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_3082() {

{
   {
      uint16x4_t arg1;
      poly16x4_t arg2;
      poly16x4_t arg3;
      poly16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"bsl\", fnname = \"vbsl_p16\", rettype = \"poly16x4_t\", argtypes = \"[uint16x4_t,poly16x4_t,poly16x4_t]\", vals = [VectorVal [IntegerVal 65535,IntegerVal 65535,IntegerVal 0,IntegerVal 32768],VectorVal [PolyVal [1,1,0,0,1,0,0,1,1,1,0,1,1,0,0,0],PolyVal [1,1,1,1,1,0,0,1,0,1,1,0,1,1,1,0],PolyVal [0,1,1,1,0,0,1,1,1,1,1,1,1,1,1,0],PolyVal [1,1,0,1,1,1,1,1,0,1,1,0,1,1,0,0]],VectorVal [PolyVal [1,0,1,0,1,0,1,1,0,0,0,1,0,1,1,1],PolyVal [0,1,1,0,1,0,1,1,0,0,1,1,0,1,0,1],PolyVal [0,0,0,1,1,0,1,0,0,1,1,0,1,1,0,0],PolyVal [0,0,0,1,0,0,0,1,0,1,1,0,1,0,1,0]]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u16(UINT64_C(0x80000000ffffffff));
      arg2 = vcreate_p16(UINT64_C(0x36fb7fce769f1b93));
      arg3 = vcreate_p16(UINT64_C(0x56883658acd6e8d5));
      clear_neon_saturated();
      //  Expect: "result" = 56883658769f1b93
      result = vbsl_p16(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_p16(result), 0);
      exp = UINT64_C(0x56883658769f1b93);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_3083() {

{
   {
      uint8x16_t arg1;
      int8x16_t arg2;
      int8x16_t arg3;
      int8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"bsl\", fnname = \"vbslq_s8\", rettype = \"int8x16_t\", argtypes = \"[uint8x16_t,int8x16_t,int8x16_t]\", vals = [VectorVal [IntegerVal 128,IntegerVal 128,IntegerVal 128,IntegerVal 0,IntegerVal 127,IntegerVal 255,IntegerVal 128,IntegerVal 0,IntegerVal 128,IntegerVal 56,IntegerVal 127,IntegerVal 0,IntegerVal 0,IntegerVal 0,IntegerVal 236,IntegerVal 128],VectorVal [IntegerVal 127,IntegerVal 127,IntegerVal 0,IntegerVal 0,IntegerVal (-128),IntegerVal 63,IntegerVal 127,IntegerVal 0,IntegerVal 0,IntegerVal 4,IntegerVal 127,IntegerVal 0,IntegerVal 0,IntegerVal (-128),IntegerVal (-51),IntegerVal 0],VectorVal [IntegerVal (-128),IntegerVal 127,IntegerVal 75,IntegerVal 101,IntegerVal (-128),IntegerVal (-1),IntegerVal (-128),IntegerVal 127,IntegerVal 127,IntegerVal 0,IntegerVal (-1),IntegerVal (-84),IntegerVal 127,IntegerVal (-1),IntegerVal 107,IntegerVal 127]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u8(vcreate_u8(UINT64_C(0x0080ff7f00808080)),
                         vcreate_u8(UINT64_C(0x80ec0000007f3880)));
      arg2 = vcombine_s8(vcreate_s8(UINT64_C(0x007f3f8000007f7f)),
                         vcreate_s8(UINT64_C(0x00cd8000007f0400)));
      arg3 = vcombine_s8(vcreate_s8(UINT64_C(0x7f80ff80654b7f80)),
                         vcreate_s8(UINT64_C(0x7f6bff7facff007f)));
      clear_neon_saturated();
      //  Expect: "result" = 7fcfff7facff007f7f003f80654b7f00
      result = vbslq_s8(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result), 0);
         exp = UINT64_C(0x7f003f80654b7f00);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result), 1);
         exp = UINT64_C(0x7fcfff7facff007f);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_3084() {

{
   {
      uint16x8_t arg1;
      int16x8_t arg2;
      int16x8_t arg3;
      int16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"bsl\", fnname = \"vbslq_s16\", rettype = \"int16x8_t\", argtypes = \"[uint16x8_t,int16x8_t,int16x8_t]\", vals = [VectorVal [IntegerVal 20846,IntegerVal 0,IntegerVal 32767,IntegerVal 0,IntegerVal 32767,IntegerVal 53296,IntegerVal 32767,IntegerVal 32768],VectorVal [IntegerVal (-1),IntegerVal 0,IntegerVal (-1),IntegerVal (-1),IntegerVal 0,IntegerVal 32767,IntegerVal 0,IntegerVal (-4164)],VectorVal [IntegerVal (-32768),IntegerVal (-32768),IntegerVal 13984,IntegerVal (-32768),IntegerVal (-1),IntegerVal (-1),IntegerVal (-32768),IntegerVal (-32768)]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u16(vcreate_u16(UINT64_C(0x00007fff0000516e)),
                          vcreate_u16(UINT64_C(0x80007fffd0307fff)));
      arg2 = vcombine_s16(vcreate_s16(UINT64_C(0xffffffff0000ffff)),
                          vcreate_s16(UINT64_C(0xefbc00007fff0000)));
      arg3 = vcombine_s16(vcreate_s16(UINT64_C(0x800036a080008000)),
                          vcreate_s16(UINT64_C(0x80008000ffffffff)));
      clear_neon_saturated();
      //  Expect: "result" = 800080007fff800080007fff8000d16e
      result = vbslq_s16(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 0);
         exp = UINT64_C(0x80007fff8000d16e);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 1);
         exp = UINT64_C(0x800080007fff8000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_3085() {

{
   {
      uint32x4_t arg1;
      int32x4_t arg2;
      int32x4_t arg3;
      int32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"bsl\", fnname = \"vbslq_s32\", rettype = \"int32x4_t\", argtypes = \"[uint32x4_t,int32x4_t,int32x4_t]\", vals = [VectorVal [IntegerVal 34505,IntegerVal 2147516416,IntegerVal 2147483647,IntegerVal 2147516415],VectorVal [IntegerVal 65535,IntegerVal (-2027814913),IntegerVal 2147450880,IntegerVal 2147418112],VectorVal [IntegerVal (-1),IntegerVal (-1453654017),IntegerVal (-20811),IntegerVal 2147418112]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u32(vcreate_u32(UINT64_C(0x80008000000086c9)),
                          vcreate_u32(UINT64_C(0x80007fff7fffffff)));
      arg2 = vcombine_s32(vcreate_s32(UINT64_C(0x8721ffff0000ffff)),
                          vcreate_s32(UINT64_C(0x7fff00007fff8000)));
      arg3 = vcombine_s32(vcreate_s32(UINT64_C(0xa95affffffffffff)),
                          vcreate_s32(UINT64_C(0x7fff0000ffffaeb5)));
      clear_neon_saturated();
      //  Expect: "result" = 7fff0000ffff8000a95affffffffffff
      result = vbslq_s32(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 0);
         exp = UINT64_C(0xa95affffffffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 1);
         exp = UINT64_C(0x7fff0000ffff8000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_3086() {

{
   {
      uint64x2_t arg1;
      int64x2_t arg2;
      int64x2_t arg3;
      int64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"bsl\", fnname = \"vbslq_s64\", rettype = \"int64x2_t\", argtypes = \"[uint64x2_t,int64x2_t,int64x2_t]\", vals = [VectorVal [IntegerVal 8678577221578850303,IntegerVal 9223372032559874047],VectorVal [IntegerVal 9223231302395887616,IntegerVal 3908510049273675776],VectorVal [IntegerVal 281472829286258,IntegerVal 9223247424821133311]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u64(vcreate_u64(UINT64_C(0x787080008000ffff)),
                          vcreate_u64(UINT64_C(0x7fffffff0000ffff)));
      arg2 = vcombine_s64(vcreate_s64(UINT64_C(0x7fff8000b4920000)),
                          vcreate_s64(UINT64_C(0x363dd12e80008000)));
      arg3 = vcombine_s64(vcreate_s64(UINT64_C(0x0000ffff8000e772)),
                          vcreate_s64(UINT64_C(0x7fff8eaa7fffffff)));
      clear_neon_saturated();
      //  Expect: "result" = 363dd12e7fff80007870ffff80000000
      result = vbslq_s64(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 0);
         exp = UINT64_C(0x7870ffff80000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 1);
         exp = UINT64_C(0x363dd12e7fff8000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_3087() {

{
   {
      uint8x16_t arg1;
      uint8x16_t arg2;
      uint8x16_t arg3;
      uint8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"bsl\", fnname = \"vbslq_u8\", rettype = \"uint8x16_t\", argtypes = \"[uint8x16_t,uint8x16_t,uint8x16_t]\", vals = [VectorVal [IntegerVal 0,IntegerVal 127,IntegerVal 142,IntegerVal 127,IntegerVal 127,IntegerVal 46,IntegerVal 128,IntegerVal 255,IntegerVal 127,IntegerVal 0,IntegerVal 255,IntegerVal 0,IntegerVal 241,IntegerVal 127,IntegerVal 128,IntegerVal 128],VectorVal [IntegerVal 0,IntegerVal 127,IntegerVal 128,IntegerVal 127,IntegerVal 184,IntegerVal 127,IntegerVal 255,IntegerVal 0,IntegerVal 10,IntegerVal 254,IntegerVal 255,IntegerVal 63,IntegerVal 0,IntegerVal 219,IntegerVal 167,IntegerVal 243],VectorVal [IntegerVal 128,IntegerVal 0,IntegerVal 0,IntegerVal 61,IntegerVal 255,IntegerVal 0,IntegerVal 255,IntegerVal 128,IntegerVal 255,IntegerVal 0,IntegerVal 127,IntegerVal 0,IntegerVal 127,IntegerVal 0,IntegerVal 0,IntegerVal 128]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u8(vcreate_u8(UINT64_C(0xff802e7f7f8e7f00)),
                         vcreate_u8(UINT64_C(0x80807ff100ff007f)));
      arg2 = vcombine_u8(vcreate_u8(UINT64_C(0x00ff7fb87f807f00)),
                         vcreate_u8(UINT64_C(0xf3a7db003ffffe0a)));
      arg3 = vcombine_u8(vcreate_u8(UINT64_C(0x80ff00ff3d000080)),
                         vcreate_u8(UINT64_C(0x8000007f007f00ff)));
      clear_neon_saturated();
      //  Expect: "result" = 80805b0e00ff008a00ff2eb87f807f80
      result = vbslq_u8(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 0);
         exp = UINT64_C(0x00ff2eb87f807f80);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 1);
         exp = UINT64_C(0x80805b0e00ff008a);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_3088() {

{
   {
      uint16x8_t arg1;
      uint16x8_t arg2;
      uint16x8_t arg3;
      uint16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"bsl\", fnname = \"vbslq_u16\", rettype = \"uint16x8_t\", argtypes = \"[uint16x8_t,uint16x8_t,uint16x8_t]\", vals = [VectorVal [IntegerVal 60347,IntegerVal 32767,IntegerVal 5557,IntegerVal 32768,IntegerVal 32767,IntegerVal 32767,IntegerVal 65535,IntegerVal 48937],VectorVal [IntegerVal 53095,IntegerVal 65535,IntegerVal 32768,IntegerVal 65535,IntegerVal 65535,IntegerVal 32767,IntegerVal 32767,IntegerVal 54255],VectorVal [IntegerVal 34430,IntegerVal 32768,IntegerVal 65535,IntegerVal 2857,IntegerVal 0,IntegerVal 65535,IntegerVal 32767,IntegerVal 65535]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u16(vcreate_u16(UINT64_C(0x800015b57fffebbb)),
                          vcreate_u16(UINT64_C(0xbf29ffff7fff7fff)));
      arg2 = vcombine_u16(vcreate_u16(UINT64_C(0xffff8000ffffcf67)),
                          vcreate_u16(UINT64_C(0xd3ef7fff7fffffff)));
      arg3 = vcombine_u16(vcreate_u16(UINT64_C(0x0b29ffff8000867e)),
                          vcreate_u16(UINT64_C(0xffff7fffffff0000)));
      clear_neon_saturated();
      //  Expect: "result" = d3ff7fffffff7fff8b29ea4affffcf67
      result = vbslq_u16(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 0);
         exp = UINT64_C(0x8b29ea4affffcf67);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 1);
         exp = UINT64_C(0xd3ff7fffffff7fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_3089() {

{
   {
      uint32x4_t arg1;
      uint32x4_t arg2;
      uint32x4_t arg3;
      uint32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"bsl\", fnname = \"vbslq_u32\", rettype = \"uint32x4_t\", argtypes = \"[uint32x4_t,uint32x4_t,uint32x4_t]\", vals = [VectorVal [IntegerVal 2147549183,IntegerVal 32768,IntegerVal 2147516415,IntegerVal 4294934528],VectorVal [IntegerVal 1874337319,IntegerVal 2147503370,IntegerVal 1193705472,IntegerVal 1191603159],VectorVal [IntegerVal 2147516415,IntegerVal 0,IntegerVal 2147450879,IntegerVal 2147483647]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u32(vcreate_u32(UINT64_C(0x000080008000ffff)),
                          vcreate_u32(UINT64_C(0xffff800080007fff)));
      arg2 = vcombine_u32(vcreate_u32(UINT64_C(0x80004d0a6fb81e27)),
                          vcreate_u32(UINT64_C(0x47066bd747268000)));
      arg3 = vcombine_u32(vcreate_u32(UINT64_C(0x0000000080007fff)),
                          vcreate_u32(UINT64_C(0x7fffffff7fff7fff)));
      clear_neon_saturated();
      //  Expect: "result" = 47067fff7fff00000000000000001e27
      result = vbslq_u32(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 0);
         exp = UINT64_C(0x0000000000001e27);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 1);
         exp = UINT64_C(0x47067fff7fff0000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_3090() {

{
   {
      uint64x2_t arg1;
      uint64x2_t arg2;
      uint64x2_t arg3;
      uint64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"bsl\", fnname = \"vbslq_u64\", rettype = \"uint64x2_t\", argtypes = \"[uint64x2_t,uint64x2_t,uint64x2_t]\", vals = [VectorVal [IntegerVal 9223512778638060740,IntegerVal 18446744071562133412],VectorVal [IntegerVal 9223231301513857688,IntegerVal 18446744071562067967],VectorVal [IntegerVal 281472829227007,IntegerVal 281474976677888]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u64(vcreate_u64(UINT64_C(0x80008000ffff6cc4)),
                          vcreate_u64(UINT64_C(0xffffffff8000ffa4)));
      arg2 = vcombine_u64(vcreate_u64(UINT64_C(0x7fff80007fff4a98)),
                          vcreate_u64(UINT64_C(0xffffffff7fffffff)));
      arg3 = vcombine_u64(vcreate_u64(UINT64_C(0x0000ffff7fffffff)),
                          vcreate_u64(UINT64_C(0x0000ffffffff8000)));
      clear_neon_saturated();
      //  Expect: "result" = ffffffff7fffffa40000ffff7fffdbbb
      result = vbslq_u64(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 0);
         exp = UINT64_C(0x0000ffff7fffdbbb);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 1);
         exp = UINT64_C(0xffffffff7fffffa4);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_3091() {

{
   {
      uint32x4_t arg1;
      float32x4_t arg2;
      float32x4_t arg3;
      float32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"bsl\", fnname = \"vbslq_f32\", rettype = \"float32x4_t\", argtypes = \"[uint32x4_t,float32x4_t,float32x4_t]\", vals = [VectorVal [IntegerVal 2147483647,IntegerVal 65535,IntegerVal 4294934527,IntegerVal 4294934527],VectorVal [FloatVal 0.4657136797904968,FloatVal 0.9668473601341248,FloatVal 0.5991132259368896,FloatVal 0.13106316328048706],VectorVal [FloatVal 0.47371768951416016,FloatVal 0.152346670627594,FloatVal 0.14468955993652344,FloatVal 0.7176327109336853]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u32(vcreate_u32(UINT64_C(0x0000ffff7fffffff)),
                          vcreate_u32(UINT64_C(0xffff7fffffff7fff)));
      arg2 = vcombine_f32(vcreate_f32(UINT64_C(0x3f77834f3eee7206)),
                          vcreate_f32(UINT64_C(0x3e06356c3f195f7c)));
      arg3 = vcombine_f32(vcreate_f32(UINT64_C(0x3e1c00c43ef28b20)),
                          vcreate_f32(UINT64_C(0x3f37b6c73e142980)));
      clear_neon_saturated();
      //  Expect: "result" = 3e06b56c3f195f7c3e1c834f3eee7206
      result = vbslq_f32(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 0);
         exp = ((float32_t) 0.4657136797904968);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 1);
         exp = ((float32_t) 0.1528446525335312);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 2);
         exp = ((float32_t) 0.5991132259368896);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 2 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 3);
         exp = ((float32_t) 0.13155144453048706);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 3 ", exp, got);
            }
      }
   }
}
}
void dotests_3092() {

{
   {
      uint8x16_t arg1;
      poly8x16_t arg2;
      poly8x16_t arg3;
      poly8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"bsl\", fnname = \"vbslq_p8\", rettype = \"poly8x16_t\", argtypes = \"[uint8x16_t,poly8x16_t,poly8x16_t]\", vals = [VectorVal [IntegerVal 128,IntegerVal 0,IntegerVal 255,IntegerVal 255,IntegerVal 128,IntegerVal 255,IntegerVal 0,IntegerVal 127,IntegerVal 42,IntegerVal 79,IntegerVal 128,IntegerVal 0,IntegerVal 255,IntegerVal 255,IntegerVal 127,IntegerVal 0],VectorVal [PolyVal [1,0,0,0,1,1,0,0],PolyVal [1,1,1,1,1,1,1,0],PolyVal [0,0,0,1,0,0,1,0],PolyVal [1,1,0,1,0,0,1,0],PolyVal [1,0,1,0,1,0,0,1],PolyVal [1,0,1,0,1,1,1,1],PolyVal [1,1,0,1,0,1,0,0],PolyVal [0,0,0,1,1,0,1,1],PolyVal [0,1,1,1,1,0,0,0],PolyVal [1,0,1,0,1,0,1,0],PolyVal [0,0,0,1,1,1,0,1],PolyVal [1,0,1,1,1,0,0,1],PolyVal [1,1,0,0,0,0,1,1],PolyVal [1,0,0,0,1,1,1,0],PolyVal [1,1,1,0,0,0,0,0],PolyVal [0,1,1,0,0,0,1,0]],VectorVal [PolyVal [0,0,1,1,1,1,0,0],PolyVal [1,1,0,0,1,0,1,0],PolyVal [1,0,1,0,0,0,0,0],PolyVal [1,0,1,0,1,0,0,1],PolyVal [1,1,0,1,1,0,0,0],PolyVal [1,0,1,0,1,0,0,1],PolyVal [0,0,0,1,0,1,1,0],PolyVal [0,0,1,1,1,0,1,1],PolyVal [1,0,1,0,1,1,1,1],PolyVal [0,1,1,0,0,0,1,0],PolyVal [1,1,1,1,0,0,0,0],PolyVal [0,1,0,0,1,0,0,1],PolyVal [1,0,1,1,0,0,1,1],PolyVal [1,1,1,1,0,1,1,1],PolyVal [0,1,1,1,1,0,0,0],PolyVal [1,1,1,0,1,1,0,1]]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u8(vcreate_u8(UINT64_C(0x7f00ff80ffff0080)),
                         vcreate_u8(UINT64_C(0x007fffff00804f2a)));
      arg2 = vcombine_p8(vcreate_p8(UINT64_C(0xd82bf5954b487f31)),
                         vcreate_p8(UINT64_C(0x460771c39db8551e)));
      arg3 = vcombine_p8(vcreate_p8(UINT64_C(0xdc68951b9505533c)),
                         vcreate_p8(UINT64_C(0xb71eefcd920f46f5)));
      clear_neon_saturated();
      //  Expect: "result" = b70771c3928f45dfd868f59b4b48533c
      result = vbslq_p8(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p8(result), 0);
         exp = UINT64_C(0xd868f59b4b48533c);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p8(result), 1);
         exp = UINT64_C(0xb70771c3928f45df);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_3093() {

{
   {
      uint16x8_t arg1;
      poly16x8_t arg2;
      poly16x8_t arg3;
      poly16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"bsl\", fnname = \"vbslq_p16\", rettype = \"poly16x8_t\", argtypes = \"[uint16x8_t,poly16x8_t,poly16x8_t]\", vals = [VectorVal [IntegerVal 32767,IntegerVal 32768,IntegerVal 32767,IntegerVal 65535,IntegerVal 20100,IntegerVal 3354,IntegerVal 32767,IntegerVal 0],VectorVal [PolyVal [1,1,0,1,0,0,1,0,0,1,0,1,1,0,0,1],PolyVal [0,0,1,1,1,1,1,1,1,0,1,1,1,1,0,0],PolyVal [1,0,0,1,0,0,0,0,1,0,0,0,0,1,0,1],PolyVal [1,1,0,1,1,1,0,1,1,0,1,1,0,1,1,1],PolyVal [0,0,1,0,1,0,1,1,1,1,1,1,0,1,1,1],PolyVal [1,0,1,0,1,1,1,1,0,1,0,0,1,1,1,1],PolyVal [0,1,1,1,0,1,0,1,1,1,0,0,1,0,1,0],PolyVal [1,0,1,0,0,0,1,1,0,1,0,0,0,0,0,1]],VectorVal [PolyVal [0,0,0,0,0,1,0,0,0,1,1,1,0,1,1,1],PolyVal [1,1,0,0,1,1,0,1,0,1,1,1,0,1,1,0],PolyVal [1,1,1,1,1,1,0,1,1,0,1,0,0,1,1,1],PolyVal [1,1,1,0,0,1,0,1,1,0,1,1,0,1,1,1],PolyVal [0,1,1,0,1,1,1,0,0,0,1,1,0,1,0,0],PolyVal [1,0,0,0,0,0,1,1,0,1,0,1,1,0,0,0],PolyVal [0,0,1,1,1,0,0,0,1,1,0,1,1,0,1,1],PolyVal [1,0,1,1,0,0,1,0,0,1,0,0,1,1,0,0]]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u16(vcreate_u16(UINT64_C(0xffff7fff80007fff)),
                          vcreate_u16(UINT64_C(0x00007fff0d1a4e84)));
      arg2 = vcombine_p16(vcreate_p16(UINT64_C(0xedbba1093dfc9a4b)),
                          vcreate_p16(UINT64_C(0x82c553aef2f5efd4)));
      arg3 = vcombine_p16(vcreate_p16(UINT64_C(0xeda7e5bf6eb3ee20)),
                          vcreate_p16(UINT64_C(0x324ddb1c1ac12c76)));
      clear_neon_saturated();
      //  Expect: "result" = 324dd3ae12d16ef6edbba1096eb39a4b
      result = vbslq_p16(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p16(result), 0);
         exp = UINT64_C(0xedbba1096eb39a4b);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p16(result), 1);
         exp = UINT64_C(0x324dd3ae12d16ef6);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_3094() {

{
   {
      uint64x1_t arg1;
      float64x1_t arg2;
      float64x1_t arg3;
      float64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"bsl\", fnname = \"vbsl_f64\", rettype = \"float64x1_t\", argtypes = \"[uint64x1_t,float64x1_t,float64x1_t]\", vals = [VectorVal [IntegerVal 140733193420799],VectorVal [FloatVal 9.577544600361398e-2],VectorVal [FloatVal 0.3138166282390067]], start_saturated = False}";
      int reported = 0;
      float64_t got;
      float64_t exp;
      arg1 = vcreate_u64(UINT64_C(0x00007fff00007fff));
      arg2 = vcreate_f64(UINT64_C(0x3fb884bd585867f0));
      arg3 = vcreate_f64(UINT64_C(0x3fd4159256ce8fc0));
      clear_neon_saturated();
      //  Expect: "result" = 3fd404bd56cee7f0
      result = vbsl_f64(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_f64(result, 0);
      exp = 0.3127892825829113;
      if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
         }
   }
}
}
void dotests_3095() {

{
   {
      uint64x2_t arg1;
      float64x2_t arg2;
      float64x2_t arg3;
      float64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"bsl\", fnname = \"vbslq_f64\", rettype = \"float64x2_t\", argtypes = \"[uint64x2_t,float64x2_t,float64x2_t]\", vals = [VectorVal [IntegerVal 9223372039002292224,IntegerVal 18446744069414584320],VectorVal [FloatVal 0.8716647960118437,FloatVal 0.5933681201393357],VectorVal [FloatVal 0.9157408133684048,FloatVal 5.804542255305889e-2]], start_saturated = True}";
      int reported = 0;
      arg1 = vcombine_u64(vcreate_u64(UINT64_C(0x8000000080008000)),
                          vcreate_u64(UINT64_C(0xffffffff00000000)));
      arg2 = vcombine_f64(vcreate_f64(UINT64_C(0x3febe4ad91fe408d)),
                          vcreate_f64(UINT64_C(0x3fe2fcdf23cf9928)));
      arg3 = vcombine_f64(vcreate_f64(UINT64_C(0x3fed4dbfada0f39e)),
                          vcreate_f64(UINT64_C(0x3fadb8212f1884e0)));
      set_neon_saturated();
      //  Expect: "result" = 3fe2fcdf2f1884e03fed4dbfada0739e
      result = vbslq_f64(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      {
         float64_t got;
         float64_t exp;
         got = vgetq_lane_f64(result, 0);
         exp = 0.9157408133647669;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float64_t got;
         float64_t exp;
         got = vgetq_lane_f64(result, 1);
         exp = 0.5933681411590008;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
   }
}
}
void dotests_3096() {

{
   {
      int8x8_t arg1;
      int8x8_t arg2;
      int8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"trn1\", fnname = \"vtrn1_s8\", rettype = \"int8x8_t\", argtypes = \"[int8x8_t,int8x8_t]\", vals = [VectorVal [IntegerVal (-1),IntegerVal 127,IntegerVal 127,IntegerVal (-1),IntegerVal (-1),IntegerVal (-128),IntegerVal (-128),IntegerVal (-128)],VectorVal [IntegerVal (-128),IntegerVal (-11),IntegerVal (-128),IntegerVal (-1),IntegerVal (-128),IntegerVal (-1),IntegerVal 0,IntegerVal 127]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s8(UINT64_C(0x808080ffff7f7fff));
      arg2 = vcreate_s8(UINT64_C(0x7f00ff80ff80f580));
      clear_neon_saturated();
      //  Expect: "result" = 008080ff807f80ff
      result = vtrn1_s8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s8(result), 0);
      exp = UINT64_C(0x008080ff807f80ff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_3097() {

{
   {
      int8x8_t arg1;
      int8x8_t arg2;
      int8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"trn2\", fnname = \"vtrn2_s8\", rettype = \"int8x8_t\", argtypes = \"[int8x8_t,int8x8_t]\", vals = [VectorVal [IntegerVal 127,IntegerVal (-128),IntegerVal (-46),IntegerVal 112,IntegerVal 0,IntegerVal 127,IntegerVal (-128),IntegerVal 118],VectorVal [IntegerVal (-1),IntegerVal 127,IntegerVal (-1),IntegerVal (-128),IntegerVal 0,IntegerVal (-128),IntegerVal (-1),IntegerVal 127]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s8(UINT64_C(0x76807f0070d2807f));
      arg2 = vcreate_s8(UINT64_C(0x7fff800080ff7fff));
      clear_neon_saturated();
      //  Expect: "result" = 7f76807f80707f80
      result = vtrn2_s8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s8(result), 0);
      exp = UINT64_C(0x7f76807f80707f80);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_3098() {

{
   {
      int16x4_t arg1;
      int16x4_t arg2;
      int16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"trn1\", fnname = \"vtrn1_s16\", rettype = \"int16x4_t\", argtypes = \"[int16x4_t,int16x4_t]\", vals = [VectorVal [IntegerVal 0,IntegerVal (-32768),IntegerVal 32767,IntegerVal (-1)],VectorVal [IntegerVal (-32768),IntegerVal 26517,IntegerVal (-1),IntegerVal (-32768)]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s16(UINT64_C(0xffff7fff80000000));
      arg2 = vcreate_s16(UINT64_C(0x8000ffff67958000));
      clear_neon_saturated();
      //  Expect: "result" = ffff7fff80000000
      result = vtrn1_s16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s16(result), 0);
      exp = UINT64_C(0xffff7fff80000000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_3099() {

{
   {
      int16x4_t arg1;
      int16x4_t arg2;
      int16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"trn2\", fnname = \"vtrn2_s16\", rettype = \"int16x4_t\", argtypes = \"[int16x4_t,int16x4_t]\", vals = [VectorVal [IntegerVal 32767,IntegerVal (-1),IntegerVal 4757,IntegerVal 17726],VectorVal [IntegerVal (-32318),IntegerVal (-1229),IntegerVal (-26157),IntegerVal (-1)]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s16(UINT64_C(0x453e1295ffff7fff));
      arg2 = vcreate_s16(UINT64_C(0xffff99d3fb3381c2));
      clear_neon_saturated();
      //  Expect: "result" = ffff453efb33ffff
      result = vtrn2_s16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s16(result), 0);
      exp = UINT64_C(0xffff453efb33ffff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_3100() {

{
   {
      int32x2_t arg1;
      int32x2_t arg2;
      int32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"trn1\", fnname = \"vtrn1_s32\", rettype = \"int32x2_t\", argtypes = \"[int32x2_t,int32x2_t]\", vals = [VectorVal [IntegerVal 2147418112,IntegerVal 2147462760],VectorVal [IntegerVal 2147418112,IntegerVal 45875200]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s32(UINT64_C(0x7fffae687fff0000));
      arg2 = vcreate_s32(UINT64_C(0x02bc00007fff0000));
      clear_neon_saturated();
      //  Expect: "result" = 7fff00007fff0000
      result = vtrn1_s32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s32(result), 0);
      exp = UINT64_C(0x7fff00007fff0000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_3101() {

{
   {
      int32x2_t arg1;
      int32x2_t arg2;
      int32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"trn2\", fnname = \"vtrn2_s32\", rettype = \"int32x2_t\", argtypes = \"[int32x2_t,int32x2_t]\", vals = [VectorVal [IntegerVal (-56126),IntegerVal (-65536)],VectorVal [IntegerVal (-65536),IntegerVal (-2147483648)]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s32(UINT64_C(0xffff0000ffff24c2));
      arg2 = vcreate_s32(UINT64_C(0x80000000ffff0000));
      clear_neon_saturated();
      //  Expect: "result" = 80000000ffff0000
      result = vtrn2_s32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s32(result), 0);
      exp = UINT64_C(0x80000000ffff0000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_3102() {

{
   {
      uint8x8_t arg1;
      uint8x8_t arg2;
      uint8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"trn1\", fnname = \"vtrn1_u8\", rettype = \"uint8x8_t\", argtypes = \"[uint8x8_t,uint8x8_t]\", vals = [VectorVal [IntegerVal 255,IntegerVal 0,IntegerVal 128,IntegerVal 255,IntegerVal 255,IntegerVal 56,IntegerVal 0,IntegerVal 127],VectorVal [IntegerVal 255,IntegerVal 255,IntegerVal 235,IntegerVal 128,IntegerVal 206,IntegerVal 128,IntegerVal 97,IntegerVal 128]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u8(UINT64_C(0x7f0038ffff8000ff));
      arg2 = vcreate_u8(UINT64_C(0x806180ce80ebffff));
      clear_neon_saturated();
      //  Expect: "result" = 6100ceffeb80ffff
      result = vtrn1_u8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u8(result), 0);
      exp = UINT64_C(0x6100ceffeb80ffff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_3103() {

{
   {
      uint8x8_t arg1;
      uint8x8_t arg2;
      uint8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"trn2\", fnname = \"vtrn2_u8\", rettype = \"uint8x8_t\", argtypes = \"[uint8x8_t,uint8x8_t]\", vals = [VectorVal [IntegerVal 128,IntegerVal 30,IntegerVal 128,IntegerVal 127,IntegerVal 127,IntegerVal 127,IntegerVal 0,IntegerVal 127],VectorVal [IntegerVal 127,IntegerVal 128,IntegerVal 0,IntegerVal 0,IntegerVal 127,IntegerVal 0,IntegerVal 239,IntegerVal 0]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u8(UINT64_C(0x7f007f7f7f801e80));
      arg2 = vcreate_u8(UINT64_C(0x00ef007f0000807f));
      clear_neon_saturated();
      //  Expect: "result" = 007f007f007f801e
      result = vtrn2_u8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u8(result), 0);
      exp = UINT64_C(0x007f007f007f801e);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_3104() {

{
   {
      uint16x4_t arg1;
      uint16x4_t arg2;
      uint16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"trn1\", fnname = \"vtrn1_u16\", rettype = \"uint16x4_t\", argtypes = \"[uint16x4_t,uint16x4_t]\", vals = [VectorVal [IntegerVal 36044,IntegerVal 0,IntegerVal 0,IntegerVal 32768],VectorVal [IntegerVal 0,IntegerVal 32768,IntegerVal 32972,IntegerVal 32767]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u16(UINT64_C(0x8000000000008ccc));
      arg2 = vcreate_u16(UINT64_C(0x7fff80cc80000000));
      clear_neon_saturated();
      //  Expect: "result" = 80cc000000008ccc
      result = vtrn1_u16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u16(result), 0);
      exp = UINT64_C(0x80cc000000008ccc);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_3105() {

{
   {
      uint16x4_t arg1;
      uint16x4_t arg2;
      uint16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"trn2\", fnname = \"vtrn2_u16\", rettype = \"uint16x4_t\", argtypes = \"[uint16x4_t,uint16x4_t]\", vals = [VectorVal [IntegerVal 32767,IntegerVal 19172,IntegerVal 0,IntegerVal 32767],VectorVal [IntegerVal 65535,IntegerVal 51651,IntegerVal 32767,IntegerVal 32768]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u16(UINT64_C(0x7fff00004ae47fff));
      arg2 = vcreate_u16(UINT64_C(0x80007fffc9c3ffff));
      clear_neon_saturated();
      //  Expect: "result" = 80007fffc9c34ae4
      result = vtrn2_u16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u16(result), 0);
      exp = UINT64_C(0x80007fffc9c34ae4);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_3106() {

{
   {
      uint32x2_t arg1;
      uint32x2_t arg2;
      uint32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"trn1\", fnname = \"vtrn1_u32\", rettype = \"uint32x2_t\", argtypes = \"[uint32x2_t,uint32x2_t]\", vals = [VectorVal [IntegerVal 2147516416,IntegerVal 2147418112],VectorVal [IntegerVal 2147418112,IntegerVal 0]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u32(UINT64_C(0x7fff000080008000));
      arg2 = vcreate_u32(UINT64_C(0x000000007fff0000));
      clear_neon_saturated();
      //  Expect: "result" = 7fff000080008000
      result = vtrn1_u32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u32(result), 0);
      exp = UINT64_C(0x7fff000080008000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_3107() {

{
   {
      uint32x2_t arg1;
      uint32x2_t arg2;
      uint32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"trn2\", fnname = \"vtrn2_u32\", rettype = \"uint32x2_t\", argtypes = \"[uint32x2_t,uint32x2_t]\", vals = [VectorVal [IntegerVal 32767,IntegerVal 65535],VectorVal [IntegerVal 423362560,IntegerVal 2177236991]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u32(UINT64_C(0x0000ffff00007fff));
      arg2 = vcreate_u32(UINT64_C(0x81c5ffff193c0000));
      clear_neon_saturated();
      //  Expect: "result" = 81c5ffff0000ffff
      result = vtrn2_u32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u32(result), 0);
      exp = UINT64_C(0x81c5ffff0000ffff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_3108() {

{
   {
      poly8x8_t arg1;
      poly8x8_t arg2;
      poly8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"trn1\", fnname = \"vtrn1_p8\", rettype = \"poly8x8_t\", argtypes = \"[poly8x8_t,poly8x8_t]\", vals = [VectorVal [PolyVal [0,0,0,1,0,0,0,1],PolyVal [0,1,0,1,0,1,1,1],PolyVal [0,0,1,0,1,1,0,0],PolyVal [0,0,1,1,0,0,1,0],PolyVal [1,0,1,0,1,0,0,1],PolyVal [1,1,1,1,0,0,0,1],PolyVal [1,1,1,0,0,0,1,1],PolyVal [1,1,1,1,0,0,0,0]],VectorVal [PolyVal [1,1,1,0,1,1,1,0],PolyVal [1,0,1,0,1,0,1,1],PolyVal [0,0,1,1,1,1,1,1],PolyVal [1,0,1,0,0,0,0,0],PolyVal [0,0,1,1,1,1,1,1],PolyVal [1,1,1,1,1,1,1,1],PolyVal [1,0,0,1,0,0,1,0],PolyVal [1,1,0,1,1,1,1,1]]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_p8(UINT64_C(0x0fc78f954c34ea88));
      arg2 = vcreate_p8(UINT64_C(0xfb49fffc05fcd577));
      clear_neon_saturated();
      //  Expect: "result" = 49c7fc95fc347788
      result = vtrn1_p8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_p8(result), 0);
      exp = UINT64_C(0x49c7fc95fc347788);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_3109() {

{
   {
      poly8x8_t arg1;
      poly8x8_t arg2;
      poly8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"trn2\", fnname = \"vtrn2_p8\", rettype = \"poly8x8_t\", argtypes = \"[poly8x8_t,poly8x8_t]\", vals = [VectorVal [PolyVal [1,1,0,1,1,1,1,1],PolyVal [0,0,1,0,0,0,1,1],PolyVal [1,0,0,1,0,1,0,1],PolyVal [1,0,1,1,0,1,1,0],PolyVal [0,1,0,1,0,0,1,1],PolyVal [0,1,1,1,1,1,0,1],PolyVal [1,0,0,0,0,0,1,0],PolyVal [1,0,0,1,1,0,1,1]],VectorVal [PolyVal [0,1,0,1,1,1,1,1],PolyVal [0,0,0,1,0,0,1,0],PolyVal [0,1,0,1,1,1,0,0],PolyVal [0,1,1,0,1,0,0,1],PolyVal [0,0,1,0,0,1,1,1],PolyVal [0,0,0,0,1,0,0,1],PolyVal [1,1,1,0,1,1,0,0],PolyVal [1,0,1,1,1,1,0,0]]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_p8(UINT64_C(0xd941beca6da9c4fb));
      arg2 = vcreate_p8(UINT64_C(0x3d3790e4963a48fa));
      clear_neon_saturated();
      //  Expect: "result" = 3dd990be966d48c4
      result = vtrn2_p8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_p8(result), 0);
      exp = UINT64_C(0x3dd990be966d48c4);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_3110() {

{
   {
      poly16x4_t arg1;
      poly16x4_t arg2;
      poly16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"trn1\", fnname = \"vtrn1_p16\", rettype = \"poly16x4_t\", argtypes = \"[poly16x4_t,poly16x4_t]\", vals = [VectorVal [PolyVal [0,1,1,1,0,0,1,1,1,1,1,1,0,0,0,0],PolyVal [1,1,1,0,1,0,0,0,1,1,0,0,0,0,1,1],PolyVal [1,0,1,1,1,0,0,1,0,1,0,1,1,0,0,0],PolyVal [1,0,1,1,1,1,0,0,0,1,0,0,0,0,1,1]],VectorVal [PolyVal [0,0,1,0,1,1,1,1,1,0,0,1,1,0,1,0],PolyVal [1,0,1,0,0,0,1,1,0,1,0,0,0,0,0,1],PolyVal [0,1,0,0,1,0,1,0,0,1,1,1,1,1,1,0],PolyVal [1,0,1,0,0,1,0,0,1,0,0,1,1,1,1,0]]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_p16(UINT64_C(0xc23d1a9dc3170fce));
      arg2 = vcreate_p16(UINT64_C(0x79257e5282c559f4));
      clear_neon_saturated();
      //  Expect: "result" = 7e521a9d59f40fce
      result = vtrn1_p16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_p16(result), 0);
      exp = UINT64_C(0x7e521a9d59f40fce);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_3111() {

{
   {
      poly16x4_t arg1;
      poly16x4_t arg2;
      poly16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"trn2\", fnname = \"vtrn2_p16\", rettype = \"poly16x4_t\", argtypes = \"[poly16x4_t,poly16x4_t]\", vals = [VectorVal [PolyVal [1,1,1,1,0,0,0,1,1,0,1,0,1,0,1,1],PolyVal [0,1,1,1,0,1,1,1,1,1,1,0,0,1,0,1],PolyVal [1,0,0,0,1,1,1,1,1,0,1,0,1,0,0,0],PolyVal [1,0,0,0,1,1,1,0,0,1,1,1,0,0,0,0]],VectorVal [PolyVal [1,1,1,1,1,0,1,0,0,1,0,1,0,0,0,0],PolyVal [1,0,1,1,0,0,1,1,0,1,0,0,0,0,1,1],PolyVal [1,0,1,1,0,1,1,1,0,1,1,0,1,0,0,1],PolyVal [0,1,1,1,1,1,1,1,0,1,0,1,1,0,1,1]]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_p16(UINT64_C(0x0e7115f1a7eed58f));
      arg2 = vcreate_p16(UINT64_C(0xdafe96edc2cd0a5f));
      clear_neon_saturated();
      //  Expect: "result" = dafe0e71c2cda7ee
      result = vtrn2_p16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_p16(result), 0);
      exp = UINT64_C(0xdafe0e71c2cda7ee);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_3112() {

{
   {
      float32x2_t arg1;
      float32x2_t arg2;
      float32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"trn1\", fnname = \"vtrn1_f32\", rettype = \"float32x2_t\", argtypes = \"[float32x2_t,float32x2_t]\", vals = [VectorVal [FloatVal 0.6986274123191833,FloatVal 0.738625168800354],VectorVal [FloatVal 0.3259413242340088,FloatVal 0.6972959637641907]], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_f32(UINT64_C(0x3f3d168a3f32d93f));
      arg2 = vcreate_f32(UINT64_C(0x3f3281fd3ea6e1c8));
      clear_neon_saturated();
      //  Expect: "result" = 3ea6e1c83f32d93f
      result = vtrn1_f32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result, 0);
         exp = ((float32_t) 0.6986274123191833);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result, 1);
         exp = ((float32_t) 0.3259413242340088);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
   }
}
}
void dotests_3113() {

{
   {
      float32x2_t arg1;
      float32x2_t arg2;
      float32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"trn2\", fnname = \"vtrn2_f32\", rettype = \"float32x2_t\", argtypes = \"[float32x2_t,float32x2_t]\", vals = [VectorVal [FloatVal 0.5034509301185608,FloatVal 0.8967294692993164],VectorVal [FloatVal 0.6554956436157227,FloatVal 0.3933330774307251]], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_f32(UINT64_C(0x3f6590103f00e229));
      arg2 = vcreate_f32(UINT64_C(0x3ec962f43f27ce90));
      clear_neon_saturated();
      //  Expect: "result" = 3ec962f43f659010
      result = vtrn2_f32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result, 0);
         exp = ((float32_t) 0.8967294692993164);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result, 1);
         exp = ((float32_t) 0.3933330774307251);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
   }
}
}
void dotests_3114() {

{
   {
      int8x16_t arg1;
      int8x16_t arg2;
      int8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"trn1\", fnname = \"vtrn1q_s8\", rettype = \"int8x16_t\", argtypes = \"[int8x16_t,int8x16_t]\", vals = [VectorVal [IntegerVal (-128),IntegerVal (-128),IntegerVal 0,IntegerVal (-104),IntegerVal (-24),IntegerVal (-1),IntegerVal (-128),IntegerVal 127,IntegerVal (-128),IntegerVal (-128),IntegerVal 0,IntegerVal (-1),IntegerVal 0,IntegerVal (-73),IntegerVal (-128),IntegerVal 127],VectorVal [IntegerVal (-128),IntegerVal 0,IntegerVal (-128),IntegerVal (-128),IntegerVal 0,IntegerVal (-128),IntegerVal 0,IntegerVal 0,IntegerVal (-1),IntegerVal 127,IntegerVal (-128),IntegerVal 102,IntegerVal (-128),IntegerVal (-128),IntegerVal (-128),IntegerVal 127]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s8(vcreate_s8(UINT64_C(0x7f80ffe898008080)),
                         vcreate_s8(UINT64_C(0x7f80b700ff008080)));
      arg2 = vcombine_s8(vcreate_s8(UINT64_C(0x0000800080800080)),
                         vcreate_s8(UINT64_C(0x7f80808066807fff)));
      clear_neon_saturated();
      //  Expect: "result" = 808080008000ff80008000e880008080
      result = vtrn1q_s8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result), 0);
         exp = UINT64_C(0x008000e880008080);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result), 1);
         exp = UINT64_C(0x808080008000ff80);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_3115() {

{
   {
      int8x16_t arg1;
      int8x16_t arg2;
      int8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"trn2\", fnname = \"vtrn2q_s8\", rettype = \"int8x16_t\", argtypes = \"[int8x16_t,int8x16_t]\", vals = [VectorVal [IntegerVal 0,IntegerVal (-1),IntegerVal (-128),IntegerVal 127,IntegerVal (-1),IntegerVal 127,IntegerVal (-1),IntegerVal (-1),IntegerVal (-1),IntegerVal 0,IntegerVal 127,IntegerVal (-1),IntegerVal 0,IntegerVal 0,IntegerVal 0,IntegerVal (-66)],VectorVal [IntegerVal (-1),IntegerVal (-128),IntegerVal 127,IntegerVal 45,IntegerVal (-1),IntegerVal 127,IntegerVal (-128),IntegerVal (-128),IntegerVal (-128),IntegerVal 0,IntegerVal (-1),IntegerVal 49,IntegerVal (-128),IntegerVal (-128),IntegerVal 0,IntegerVal (-1)]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s8(vcreate_s8(UINT64_C(0xffff7fff7f80ff00)),
                         vcreate_s8(UINT64_C(0xbe000000ff7f00ff)));
      arg2 = vcombine_s8(vcreate_s8(UINT64_C(0x80807fff2d7f80ff)),
                         vcreate_s8(UINT64_C(0xff00808031ff0080)));
      clear_neon_saturated();
      //  Expect: "result" = ffbe800031ff000080ff7f7f2d7f80ff
      result = vtrn2q_s8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result), 0);
         exp = UINT64_C(0x80ff7f7f2d7f80ff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result), 1);
         exp = UINT64_C(0xffbe800031ff0000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_3116() {

{
   {
      int16x8_t arg1;
      int16x8_t arg2;
      int16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"trn1\", fnname = \"vtrn1q_s16\", rettype = \"int16x8_t\", argtypes = \"[int16x8_t,int16x8_t]\", vals = [VectorVal [IntegerVal 32767,IntegerVal (-6420),IntegerVal (-1),IntegerVal 32767,IntegerVal (-32768),IntegerVal 32767,IntegerVal (-32768),IntegerVal 0],VectorVal [IntegerVal 4819,IntegerVal (-14667),IntegerVal 6211,IntegerVal (-4098),IntegerVal 32767,IntegerVal 32767,IntegerVal 0,IntegerVal (-1)]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s16(vcreate_s16(UINT64_C(0x7fffffffe6ec7fff)),
                          vcreate_s16(UINT64_C(0x000080007fff8000)));
      arg2 = vcombine_s16(vcreate_s16(UINT64_C(0xeffe1843c6b512d3)),
                          vcreate_s16(UINT64_C(0xffff00007fff7fff)));
      clear_neon_saturated();
      //  Expect: "result" = 000080007fff80001843ffff12d37fff
      result = vtrn1q_s16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 0);
         exp = UINT64_C(0x1843ffff12d37fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 1);
         exp = UINT64_C(0x000080007fff8000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_3117() {

{
   {
      int16x8_t arg1;
      int16x8_t arg2;
      int16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"trn2\", fnname = \"vtrn2q_s16\", rettype = \"int16x8_t\", argtypes = \"[int16x8_t,int16x8_t]\", vals = [VectorVal [IntegerVal 0,IntegerVal 32767,IntegerVal 0,IntegerVal 32767,IntegerVal 26709,IntegerVal 32767,IntegerVal (-1),IntegerVal 0],VectorVal [IntegerVal 32767,IntegerVal (-32768),IntegerVal 32767,IntegerVal 0,IntegerVal (-1),IntegerVal (-32768),IntegerVal (-32768),IntegerVal (-22826)]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s16(vcreate_s16(UINT64_C(0x7fff00007fff0000)),
                          vcreate_s16(UINT64_C(0x0000ffff7fff6855)));
      arg2 = vcombine_s16(vcreate_s16(UINT64_C(0x00007fff80007fff)),
                          vcreate_s16(UINT64_C(0xa6d680008000ffff)));
      clear_neon_saturated();
      //  Expect: "result" = a6d6000080007fff00007fff80007fff
      result = vtrn2q_s16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 0);
         exp = UINT64_C(0x00007fff80007fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 1);
         exp = UINT64_C(0xa6d6000080007fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_3118() {

{
   {
      int32x4_t arg1;
      int32x4_t arg2;
      int32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"trn1\", fnname = \"vtrn1q_s32\", rettype = \"int32x4_t\", argtypes = \"[int32x4_t,int32x4_t]\", vals = [VectorVal [IntegerVal 2147483647,IntegerVal (-2147468976),IntegerVal 2147450879,IntegerVal 65535],VectorVal [IntegerVal 0,IntegerVal (-20727),IntegerVal 2147450880,IntegerVal 2147450880]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s32(vcreate_s32(UINT64_C(0x800039507fffffff)),
                          vcreate_s32(UINT64_C(0x0000ffff7fff7fff)));
      arg2 = vcombine_s32(vcreate_s32(UINT64_C(0xffffaf0900000000)),
                          vcreate_s32(UINT64_C(0x7fff80007fff8000)));
      clear_neon_saturated();
      //  Expect: "result" = 7fff80007fff7fff000000007fffffff
      result = vtrn1q_s32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 0);
         exp = UINT64_C(0x000000007fffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 1);
         exp = UINT64_C(0x7fff80007fff7fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_3119() {

{
   {
      int32x4_t arg1;
      int32x4_t arg2;
      int32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"trn2\", fnname = \"vtrn2q_s32\", rettype = \"int32x4_t\", argtypes = \"[int32x4_t,int32x4_t]\", vals = [VectorVal [IntegerVal (-2147450881),IntegerVal (-32768),IntegerVal (-984977170),IntegerVal 22182],VectorVal [IntegerVal 39219,IntegerVal 2147418112,IntegerVal 2147450879,IntegerVal 2147450880]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s32(vcreate_s32(UINT64_C(0xffff800080007fff)),
                          vcreate_s32(UINT64_C(0x000056a6c54a70ee)));
      arg2 = vcombine_s32(vcreate_s32(UINT64_C(0x7fff000000009933)),
                          vcreate_s32(UINT64_C(0x7fff80007fff7fff)));
      clear_neon_saturated();
      //  Expect: "result" = 7fff8000000056a67fff0000ffff8000
      result = vtrn2q_s32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 0);
         exp = UINT64_C(0x7fff0000ffff8000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 1);
         exp = UINT64_C(0x7fff8000000056a6);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_3120() {

{
   {
      int64x2_t arg1;
      int64x2_t arg2;
      int64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"trn1\", fnname = \"vtrn1q_s64\", rettype = \"int64x2_t\", argtypes = \"[int64x2_t,int64x2_t]\", vals = [VectorVal [IntegerVal 9223130105641992192,IntegerVal 340152993],VectorVal [IntegerVal (-2123202561),IntegerVal (-9223090564025516032)]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s64(vcreate_s64(UINT64_C(0x7fff23f700008000)),
                          vcreate_s64(UINT64_C(0x00000000144652a1)));
      arg2 = vcombine_s64(vcreate_s64(UINT64_C(0xffffffff81727fff)),
                          vcreate_s64(UINT64_C(0x8000ffff80008000)));
      clear_neon_saturated();
      //  Expect: "result" = ffffffff81727fff7fff23f700008000
      result = vtrn1q_s64(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 0);
         exp = UINT64_C(0x7fff23f700008000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 1);
         exp = UINT64_C(0xffffffff81727fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_3121() {

{
   {
      int64x2_t arg1;
      int64x2_t arg2;
      int64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"trn2\", fnname = \"vtrn2q_s64\", rettype = \"int64x2_t\", argtypes = \"[int64x2_t,int64x2_t]\", vals = [VectorVal [IntegerVal 827395689746006016,IntegerVal (-9223231297218968910)],VectorVal [IntegerVal (-9223372036854716823),IntegerVal (-9223372033643970560)]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s64(vcreate_s64(UINT64_C(0x0b7b7fff00000000)),
                          vcreate_s64(UINT64_C(0x800080007fff82b2)));
      arg2 = vcombine_s64(vcreate_s64(UINT64_C(0x800000000000e669)),
                          vcreate_s64(UINT64_C(0x80000000bf610000)));
      clear_neon_saturated();
      //  Expect: "result" = 80000000bf610000800080007fff82b2
      result = vtrn2q_s64(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 0);
         exp = UINT64_C(0x800080007fff82b2);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 1);
         exp = UINT64_C(0x80000000bf610000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_3122() {

{
   {
      uint8x16_t arg1;
      uint8x16_t arg2;
      uint8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"trn1\", fnname = \"vtrn1q_u8\", rettype = \"uint8x16_t\", argtypes = \"[uint8x16_t,uint8x16_t]\", vals = [VectorVal [IntegerVal 0,IntegerVal 128,IntegerVal 0,IntegerVal 127,IntegerVal 128,IntegerVal 86,IntegerVal 63,IntegerVal 69,IntegerVal 3,IntegerVal 37,IntegerVal 128,IntegerVal 255,IntegerVal 0,IntegerVal 127,IntegerVal 0,IntegerVal 0],VectorVal [IntegerVal 0,IntegerVal 127,IntegerVal 127,IntegerVal 128,IntegerVal 255,IntegerVal 0,IntegerVal 0,IntegerVal 214,IntegerVal 255,IntegerVal 127,IntegerVal 128,IntegerVal 127,IntegerVal 128,IntegerVal 127,IntegerVal 127,IntegerVal 128]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u8(vcreate_u8(UINT64_C(0x453f56807f008000)),
                         vcreate_u8(UINT64_C(0x00007f00ff802503)));
      arg2 = vcombine_u8(vcreate_u8(UINT64_C(0xd60000ff807f7f00)),
                         vcreate_u8(UINT64_C(0x807f7f807f807fff)));
      clear_neon_saturated();
      //  Expect: "result" = 7f0080008080ff03003fff807f000000
      result = vtrn1q_u8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 0);
         exp = UINT64_C(0x003fff807f000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 1);
         exp = UINT64_C(0x7f0080008080ff03);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_3123() {

{
   {
      uint8x16_t arg1;
      uint8x16_t arg2;
      uint8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"trn2\", fnname = \"vtrn2q_u8\", rettype = \"uint8x16_t\", argtypes = \"[uint8x16_t,uint8x16_t]\", vals = [VectorVal [IntegerVal 255,IntegerVal 0,IntegerVal 162,IntegerVal 127,IntegerVal 127,IntegerVal 255,IntegerVal 0,IntegerVal 255,IntegerVal 255,IntegerVal 127,IntegerVal 127,IntegerVal 219,IntegerVal 128,IntegerVal 128,IntegerVal 128,IntegerVal 127],VectorVal [IntegerVal 128,IntegerVal 127,IntegerVal 0,IntegerVal 128,IntegerVal 128,IntegerVal 128,IntegerVal 128,IntegerVal 148,IntegerVal 128,IntegerVal 128,IntegerVal 255,IntegerVal 0,IntegerVal 0,IntegerVal 238,IntegerVal 0,IntegerVal 73]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u8(vcreate_u8(UINT64_C(0xff00ff7f7fa200ff)),
                         vcreate_u8(UINT64_C(0x7f808080db7f7fff)));
      arg2 = vcombine_u8(vcreate_u8(UINT64_C(0x9480808080007f80)),
                         vcreate_u8(UINT64_C(0x4900ee0000ff8080)));
      clear_neon_saturated();
      //  Expect: "result" = 497fee8000db807f94ff80ff807f7f00
      result = vtrn2q_u8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 0);
         exp = UINT64_C(0x94ff80ff807f7f00);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 1);
         exp = UINT64_C(0x497fee8000db807f);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_3124() {

{
   {
      uint16x8_t arg1;
      uint16x8_t arg2;
      uint16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"trn1\", fnname = \"vtrn1q_u16\", rettype = \"uint16x8_t\", argtypes = \"[uint16x8_t,uint16x8_t]\", vals = [VectorVal [IntegerVal 59539,IntegerVal 65535,IntegerVal 65535,IntegerVal 65535,IntegerVal 58742,IntegerVal 65535,IntegerVal 56944,IntegerVal 0],VectorVal [IntegerVal 32767,IntegerVal 0,IntegerVal 32768,IntegerVal 32768,IntegerVal 32767,IntegerVal 65535,IntegerVal 11015,IntegerVal 32767]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u16(vcreate_u16(UINT64_C(0xffffffffffffe893)),
                          vcreate_u16(UINT64_C(0x0000de70ffffe576)));
      arg2 = vcombine_u16(vcreate_u16(UINT64_C(0x8000800000007fff)),
                          vcreate_u16(UINT64_C(0x7fff2b07ffff7fff)));
      clear_neon_saturated();
      //  Expect: "result" = 2b07de707fffe5768000ffff7fffe893
      result = vtrn1q_u16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 0);
         exp = UINT64_C(0x8000ffff7fffe893);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 1);
         exp = UINT64_C(0x2b07de707fffe576);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_3125() {

{
   {
      uint16x8_t arg1;
      uint16x8_t arg2;
      uint16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"trn2\", fnname = \"vtrn2q_u16\", rettype = \"uint16x8_t\", argtypes = \"[uint16x8_t,uint16x8_t]\", vals = [VectorVal [IntegerVal 32767,IntegerVal 32767,IntegerVal 32767,IntegerVal 48698,IntegerVal 32768,IntegerVal 32767,IntegerVal 32767,IntegerVal 35556],VectorVal [IntegerVal 65535,IntegerVal 0,IntegerVal 11393,IntegerVal 32767,IntegerVal 65535,IntegerVal 29792,IntegerVal 32768,IntegerVal 0]], start_saturated = True}";
      int reported = 0;
      arg1 = vcombine_u16(vcreate_u16(UINT64_C(0xbe3a7fff7fff7fff)),
                          vcreate_u16(UINT64_C(0x8ae47fff7fff8000)));
      arg2 = vcombine_u16(vcreate_u16(UINT64_C(0x7fff2c810000ffff)),
                          vcreate_u16(UINT64_C(0x000080007460ffff)));
      set_neon_saturated();
      //  Expect: "result" = 00008ae474607fff7fffbe3a00007fff
      result = vtrn2q_u16(arg1, arg2);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 0);
         exp = UINT64_C(0x7fffbe3a00007fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 1);
         exp = UINT64_C(0x00008ae474607fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_3126() {

{
   {
      uint32x4_t arg1;
      uint32x4_t arg2;
      uint32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"trn1\", fnname = \"vtrn1q_u32\", rettype = \"uint32x4_t\", argtypes = \"[uint32x4_t,uint32x4_t]\", vals = [VectorVal [IntegerVal 2147483647,IntegerVal 2147450879,IntegerVal 32767,IntegerVal 2147463340],VectorVal [IntegerVal 4209494800,IntegerVal 2362966015,IntegerVal 2147483647,IntegerVal 2147516415]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u32(vcreate_u32(UINT64_C(0x7fff7fff7fffffff)),
                          vcreate_u32(UINT64_C(0x7fffb0ac00007fff)));
      arg2 = vcombine_u32(vcreate_u32(UINT64_C(0x8cd7fffffae7cb10)),
                          vcreate_u32(UINT64_C(0x80007fff7fffffff)));
      clear_neon_saturated();
      //  Expect: "result" = 7fffffff00007ffffae7cb107fffffff
      result = vtrn1q_u32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 0);
         exp = UINT64_C(0xfae7cb107fffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 1);
         exp = UINT64_C(0x7fffffff00007fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_3127() {

{
   {
      uint32x4_t arg1;
      uint32x4_t arg2;
      uint32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"trn2\", fnname = \"vtrn2q_u32\", rettype = \"uint32x4_t\", argtypes = \"[uint32x4_t,uint32x4_t]\", vals = [VectorVal [IntegerVal 2147516415,IntegerVal 2710174562,IntegerVal 2147418112,IntegerVal 2147418112],VectorVal [IntegerVal 2147452041,IntegerVal 2147516415,IntegerVal 3711598592,IntegerVal 65535]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u32(vcreate_u32(UINT64_C(0xa189fb6280007fff)),
                          vcreate_u32(UINT64_C(0x7fff00007fff0000)));
      arg2 = vcombine_u32(vcreate_u32(UINT64_C(0x80007fff7fff8489)),
                          vcreate_u32(UINT64_C(0x0000ffffdd3a8000)));
      clear_neon_saturated();
      //  Expect: "result" = 0000ffff7fff000080007fffa189fb62
      result = vtrn2q_u32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 0);
         exp = UINT64_C(0x80007fffa189fb62);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 1);
         exp = UINT64_C(0x0000ffff7fff0000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_3128() {

{
   {
      uint64x2_t arg1;
      uint64x2_t arg2;
      uint64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"trn1\", fnname = \"vtrn1q_u64\", rettype = \"uint64x2_t\", argtypes = \"[uint64x2_t,uint64x2_t]\", vals = [VectorVal [IntegerVal 103330470658047,IntegerVal 9223231299457351551],VectorVal [IntegerVal 9223372034707279049,IntegerVal 140741783257088]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u64(vcreate_u64(UINT64_C(0x00005dfa7fff7fff)),
                          vcreate_u64(UINT64_C(0x7fff8000056b7f7f)));
      arg2 = vcombine_u64(vcreate_u64(UINT64_C(0x7fffffff7fffccc9)),
                          vcreate_u64(UINT64_C(0x00008000ffff0000)));
      clear_neon_saturated();
      //  Expect: "result" = 7fffffff7fffccc900005dfa7fff7fff
      result = vtrn1q_u64(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 0);
         exp = UINT64_C(0x00005dfa7fff7fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 1);
         exp = UINT64_C(0x7fffffff7fffccc9);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_3129() {

{
   {
      uint64x2_t arg1;
      uint64x2_t arg2;
      uint64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"trn2\", fnname = \"vtrn2q_u64\", rettype = \"uint64x2_t\", argtypes = \"[uint64x2_t,uint64x2_t]\", vals = [VectorVal [IntegerVal 18446744069632644540,IntegerVal 18446685185412890624],VectorVal [IntegerVal 140736568295424,IntegerVal 140738478614584]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u64(vcreate_u64(UINT64_C(0xffffffff0cff55bc)),
                          vcreate_u64(UINT64_C(0xffffca70ffff0000)));
      arg2 = vcombine_u64(vcreate_u64(UINT64_C(0x00007fffc9290000)),
                          vcreate_u64(UINT64_C(0x000080003b062838)));
      clear_neon_saturated();
      //  Expect: "result" = 000080003b062838ffffca70ffff0000
      result = vtrn2q_u64(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 0);
         exp = UINT64_C(0xffffca70ffff0000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 1);
         exp = UINT64_C(0x000080003b062838);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_3130() {

{
   {
      poly8x16_t arg1;
      poly8x16_t arg2;
      poly8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"trn1\", fnname = \"vtrn1q_p8\", rettype = \"poly8x16_t\", argtypes = \"[poly8x16_t,poly8x16_t]\", vals = [VectorVal [PolyVal [0,1,0,0,1,1,1,0],PolyVal [1,0,1,0,1,1,0,1],PolyVal [1,0,0,0,0,0,1,0],PolyVal [0,0,0,1,1,1,0,1],PolyVal [1,0,0,0,1,0,1,1],PolyVal [0,1,0,1,0,1,1,0],PolyVal [0,0,1,1,1,1,0,1],PolyVal [1,1,0,1,1,0,1,0],PolyVal [0,1,0,1,1,1,1,1],PolyVal [0,0,1,0,0,1,0,0],PolyVal [1,1,1,0,0,0,0,0],PolyVal [0,0,1,1,0,1,1,1],PolyVal [1,1,0,1,1,1,0,1],PolyVal [1,1,0,1,0,0,0,1],PolyVal [1,0,1,0,1,0,1,1],PolyVal [1,1,0,0,0,0,0,1]],VectorVal [PolyVal [1,0,0,0,1,1,0,1],PolyVal [0,1,1,0,1,1,1,1],PolyVal [0,1,0,1,0,1,0,0],PolyVal [1,0,0,1,0,1,1,0],PolyVal [1,1,0,1,0,0,1,1],PolyVal [1,1,0,0,0,0,0,0],PolyVal [1,1,0,1,1,1,1,0],PolyVal [1,0,0,0,0,1,1,1],PolyVal [0,0,1,0,0,0,1,0],PolyVal [0,0,0,0,1,1,1,1],PolyVal [0,1,1,0,0,1,0,0],PolyVal [1,1,1,0,0,1,1,1],PolyVal [0,1,1,0,0,0,0,0],PolyVal [0,0,0,1,0,1,0,0],PolyVal [0,0,1,0,0,0,0,0],PolyVal [0,0,1,1,0,1,1,0]]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_p8(vcreate_p8(UINT64_C(0x5bbc6ad1b841b572)),
                         vcreate_p8(UINT64_C(0x83d58bbbec0724fa)));
      arg2 = vcombine_p8(vcreate_p8(UINT64_C(0xe17b03cb692af6b1)),
                         vcreate_p8(UINT64_C(0x6c042806e726f044)));
      clear_neon_saturated();
      //  Expect: "result" = 04d506bb260744fa7bbccbd12a41b172
      result = vtrn1q_p8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p8(result), 0);
         exp = UINT64_C(0x7bbccbd12a41b172);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p8(result), 1);
         exp = UINT64_C(0x04d506bb260744fa);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_3131() {

{
   {
      poly8x16_t arg1;
      poly8x16_t arg2;
      poly8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"trn2\", fnname = \"vtrn2q_p8\", rettype = \"poly8x16_t\", argtypes = \"[poly8x16_t,poly8x16_t]\", vals = [VectorVal [PolyVal [0,0,0,1,0,0,1,0],PolyVal [1,1,0,0,1,1,1,0],PolyVal [0,1,1,0,0,1,1,0],PolyVal [0,0,0,1,0,0,0,0],PolyVal [0,1,0,0,0,1,0,1],PolyVal [0,1,0,1,0,0,0,0],PolyVal [0,1,1,1,0,0,0,1],PolyVal [0,0,0,0,0,0,1,1],PolyVal [1,1,1,1,0,0,1,1],PolyVal [0,1,0,1,1,1,1,1],PolyVal [1,0,1,1,0,0,0,0],PolyVal [0,1,1,1,0,1,1,1],PolyVal [0,0,1,1,0,0,0,1],PolyVal [0,0,0,1,0,1,0,1],PolyVal [0,0,1,1,1,1,0,0],PolyVal [1,1,1,0,1,0,0,1]],VectorVal [PolyVal [0,1,1,0,0,1,1,0],PolyVal [1,0,0,0,0,1,1,1],PolyVal [1,0,1,1,1,1,1,0],PolyVal [0,0,1,0,1,1,1,0],PolyVal [0,0,0,0,0,1,1,0],PolyVal [0,1,0,0,0,1,1,0],PolyVal [1,1,1,0,0,0,1,1],PolyVal [1,0,0,1,0,1,0,1],PolyVal [1,1,0,0,1,0,1,0],PolyVal [1,1,0,0,0,0,0,0],PolyVal [1,0,0,0,1,1,1,1],PolyVal [1,1,0,0,0,1,1,0],PolyVal [0,1,1,1,0,0,1,0],PolyVal [1,1,1,0,1,1,0,1],PolyVal [0,1,0,0,1,0,0,1],PolyVal [0,0,0,0,1,1,0,1]]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_p8(vcreate_p8(UINT64_C(0xc08e0aa208667348)),
                         vcreate_p8(UINT64_C(0x973ca88cee0dfacf)));
      arg2 = vcombine_p8(vcreate_p8(UINT64_C(0xa9c76260747de166)),
                         vcreate_p8(UINT64_C(0xb092b74e63f10353)));
      clear_neon_saturated();
      //  Expect: "result" = b097b7a863ee03faa9c0620a7408e173
      result = vtrn2q_p8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p8(result), 0);
         exp = UINT64_C(0xa9c0620a7408e173);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p8(result), 1);
         exp = UINT64_C(0xb097b7a863ee03fa);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_3132() {

{
   {
      poly16x8_t arg1;
      poly16x8_t arg2;
      poly16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"trn1\", fnname = \"vtrn1q_p16\", rettype = \"poly16x8_t\", argtypes = \"[poly16x8_t,poly16x8_t]\", vals = [VectorVal [PolyVal [1,0,1,0,0,1,1,0,1,1,1,1,0,1,1,0],PolyVal [0,1,1,0,0,1,1,0,0,1,0,0,0,1,1,0],PolyVal [1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,1],PolyVal [1,0,0,0,1,1,0,1,1,0,0,1,1,0,1,1],PolyVal [0,1,1,0,1,1,1,0,0,1,0,0,1,1,1,1],PolyVal [0,0,0,1,0,0,1,1,1,1,0,1,1,0,1,0],PolyVal [0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0],PolyVal [0,1,1,1,1,0,0,1,0,0,0,0,1,1,0,0]],VectorVal [PolyVal [0,0,0,0,1,0,0,1,1,1,0,0,0,1,0,1],PolyVal [0,1,1,0,1,0,0,1,1,0,1,0,0,0,1,0],PolyVal [0,1,0,0,0,0,1,1,1,0,1,0,0,1,0,0],PolyVal [1,0,0,1,0,1,1,0,0,1,1,0,1,1,1,1],PolyVal [0,1,0,1,0,0,1,0,0,1,1,0,1,1,0,0],PolyVal [1,0,1,1,1,0,1,1,1,0,0,1,0,1,0,1],PolyVal [1,0,0,0,1,1,1,0,0,1,1,0,0,0,1,1],PolyVal [1,0,1,0,0,0,0,0,1,1,0,1,0,0,0,0]]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_p16(vcreate_p16(UINT64_C(0xd9b18fff62666f65)),
                          vcreate_p16(UINT64_C(0x309e084a5bc8f276)));
      arg2 = vcombine_p16(vcreate_p16(UINT64_C(0xf66925c24596a390)),
                          vcreate_p16(UINT64_C(0x0b05c671a9dd364a)));
      clear_neon_saturated();
      //  Expect: "result" = c671084a364af27625c28fffa3906f65
      result = vtrn1q_p16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p16(result), 0);
         exp = UINT64_C(0x25c28fffa3906f65);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p16(result), 1);
         exp = UINT64_C(0xc671084a364af276);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_3133() {

{
   {
      poly16x8_t arg1;
      poly16x8_t arg2;
      poly16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"trn2\", fnname = \"vtrn2q_p16\", rettype = \"poly16x8_t\", argtypes = \"[poly16x8_t,poly16x8_t]\", vals = [VectorVal [PolyVal [0,1,1,1,0,1,1,1,0,1,1,0,0,1,1,0],PolyVal [1,0,1,1,0,0,1,1,1,0,1,0,1,1,1,0],PolyVal [1,0,0,1,0,0,0,0,0,1,0,0,1,1,0,1],PolyVal [0,1,0,1,0,1,0,1,1,1,1,1,1,0,1,1],PolyVal [0,0,0,1,1,1,1,0,0,1,1,0,1,0,1,0],PolyVal [0,1,0,0,1,1,0,1,1,0,1,0,0,1,0,0],PolyVal [0,1,0,0,1,0,1,1,1,0,0,0,1,0,0,1],PolyVal [0,1,0,1,1,0,0,1,1,1,1,1,1,1,1,0]],VectorVal [PolyVal [0,0,0,1,0,0,1,0,1,1,0,1,0,1,0,0],PolyVal [1,1,1,0,1,1,0,1,1,0,0,0,0,1,0,0],PolyVal [0,0,1,1,1,0,1,1,0,1,1,0,0,0,1,1],PolyVal [0,0,0,0,0,1,0,1,1,1,0,0,1,1,0,1],PolyVal [1,0,0,1,0,1,0,1,1,0,0,1,0,1,1,0],PolyVal [1,1,1,0,0,0,0,1,0,0,1,1,1,0,1,0],PolyVal [0,1,0,0,1,0,0,0,0,1,0,1,0,0,1,0],PolyVal [0,0,1,0,1,1,1,1,0,0,1,0,1,1,0,0]]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_p16(vcreate_p16(UINT64_C(0xdfaab20975cd66ee)),
                          vcreate_p16(UINT64_C(0x7f9a91d225b25678)));
      arg2 = vcombine_p16(vcreate_p16(UINT64_C(0xb3a0c6dc21b72b48)),
                          vcreate_p16(UINT64_C(0x34f44a125c8769a9)));
      clear_neon_saturated();
      //  Expect: "result" = 34f47f9a5c8725b2b3a0dfaa21b775cd
      result = vtrn2q_p16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p16(result), 0);
         exp = UINT64_C(0xb3a0dfaa21b775cd);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p16(result), 1);
         exp = UINT64_C(0x34f47f9a5c8725b2);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_3134() {

{
   {
      float32x4_t arg1;
      float32x4_t arg2;
      float32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"trn1\", fnname = \"vtrn1q_f32\", rettype = \"float32x4_t\", argtypes = \"[float32x4_t,float32x4_t]\", vals = [VectorVal [FloatVal 0.44278597831726074,FloatVal 0.1385287046432495,FloatVal 0.14856910705566406,FloatVal 0.2819055914878845],VectorVal [FloatVal 5.536675453186035e-4,FloatVal 0.14343100786209106,FloatVal 0.4332711696624756,FloatVal 9.152054786682129e-2]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_f32(vcreate_f32(UINT64_C(0x3e0dda783ee2b4d8)),
                          vcreate_f32(UINT64_C(0x3e9055ee3e182280)));
      arg2 = vcombine_f32(vcreate_f32(UINT64_C(0x3e12df943a112400)),
                          vcreate_f32(UINT64_C(0x3dbb6f203eddd5b8)));
      clear_neon_saturated();
      //  Expect: "result" = 3eddd5b83e1822803a1124003ee2b4d8
      result = vtrn1q_f32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 0);
         exp = ((float32_t) 0.44278597831726074);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 1);
         exp = ((float32_t) 5.536675453186035e-4);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 2);
         exp = ((float32_t) 0.14856910705566406);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 2 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 3);
         exp = ((float32_t) 0.4332711696624756);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 3 ", exp, got);
            }
      }
   }
}
}
void dotests_3135() {

{
   {
      float32x4_t arg1;
      float32x4_t arg2;
      float32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"trn2\", fnname = \"vtrn2q_f32\", rettype = \"float32x4_t\", argtypes = \"[float32x4_t,float32x4_t]\", vals = [VectorVal [FloatVal 0.22412168979644775,FloatVal 0.5295319557189941,FloatVal 0.19204789400100708,FloatVal 0.6273738741874695],VectorVal [FloatVal 2.738833427429199e-4,FloatVal 0.2347208857536316,FloatVal 0.9287143349647522,FloatVal 0.6270040273666382]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_f32(vcreate_f32(UINT64_C(0x3f078f683e658028)),
                          vcreate_f32(UINT64_C(0x3f209b933e44a834)));
      arg2 = vcombine_f32(vcreate_f32(UINT64_C(0x3e705aac398f9800)),
                          vcreate_f32(UINT64_C(0x3f2083563f6dc039)));
      clear_neon_saturated();
      //  Expect: "result" = 3f2083563f209b933e705aac3f078f68
      result = vtrn2q_f32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 0);
         exp = ((float32_t) 0.5295319557189941);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 1);
         exp = ((float32_t) 0.2347208857536316);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 2);
         exp = ((float32_t) 0.6273738741874695);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 2 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 3);
         exp = ((float32_t) 0.6270040273666382);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 3 ", exp, got);
            }
      }
   }
}
}
void dotests_3136() {

{
   {
      float64x2_t arg1;
      float64x2_t arg2;
      float64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"trn1\", fnname = \"vtrn1q_f64\", rettype = \"float64x2_t\", argtypes = \"[float64x2_t,float64x2_t]\", vals = [VectorVal [FloatVal 0.3714546313965341,FloatVal 0.7645010309702103],VectorVal [FloatVal 0.1451931663433761,FloatVal 0.18100148645927316]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_f64(vcreate_f64(UINT64_C(0x3fd7c5e9a572ef30)),
                          vcreate_f64(UINT64_C(0x3fe876caddb8cf8e)));
      arg2 = vcombine_f64(vcreate_f64(UINT64_C(0x3fc295b08e861418)),
                          vcreate_f64(UINT64_C(0x3fc72b0e846f5b04)));
      clear_neon_saturated();
      //  Expect: "result" = 3fc295b08e8614183fd7c5e9a572ef30
      result = vtrn1q_f64(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float64_t got;
         float64_t exp;
         got = vgetq_lane_f64(result, 0);
         exp = 0.3714546313965341;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float64_t got;
         float64_t exp;
         got = vgetq_lane_f64(result, 1);
         exp = 0.1451931663433761;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
   }
}
}
void dotests_3137() {

{
   {
      float64x2_t arg1;
      float64x2_t arg2;
      float64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"trn2\", fnname = \"vtrn2q_f64\", rettype = \"float64x2_t\", argtypes = \"[float64x2_t,float64x2_t]\", vals = [VectorVal [FloatVal 0.1539957748897579,FloatVal 1.931016080294856e-2],VectorVal [FloatVal 0.4612470224582478,FloatVal 2.486303932302314e-3]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_f64(vcreate_f64(UINT64_C(0x3fc3b622306fd504)),
                          vcreate_f64(UINT64_C(0x3f93c60af48443e0)));
      arg2 = vcombine_f64(vcreate_f64(UINT64_C(0x3fdd85123b3579ae)),
                          vcreate_f64(UINT64_C(0x3f645e2842780d00)));
      clear_neon_saturated();
      //  Expect: "result" = 3f645e2842780d003f93c60af48443e0
      result = vtrn2q_f64(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float64_t got;
         float64_t exp;
         got = vgetq_lane_f64(result, 0);
         exp = 1.931016080294856e-2;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float64_t got;
         float64_t exp;
         got = vgetq_lane_f64(result, 1);
         exp = 2.486303932302314e-3;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
   }
}
}
void dotests_3138() {

{
   {
      int8x8_t arg1;
      int8x8_t arg2;
      int8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"zip1\", fnname = \"vzip1_s8\", rettype = \"int8x8_t\", argtypes = \"[int8x8_t,int8x8_t]\", vals = [VectorVal [IntegerVal 0,IntegerVal (-111),IntegerVal (-128),IntegerVal (-1),IntegerVal (-128),IntegerVal 127,IntegerVal 0,IntegerVal 0],VectorVal [IntegerVal (-1),IntegerVal 0,IntegerVal 0,IntegerVal 127,IntegerVal 0,IntegerVal 0,IntegerVal 0,IntegerVal 31]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s8(UINT64_C(0x00007f80ff809100));
      arg2 = vcreate_s8(UINT64_C(0x1f0000007f0000ff));
      clear_neon_saturated();
      //  Expect: "result" = 7fff00800091ff00
      result = vzip1_s8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s8(result), 0);
      exp = UINT64_C(0x7fff00800091ff00);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_3139() {

{
   {
      int8x8_t arg1;
      int8x8_t arg2;
      int8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"zip2\", fnname = \"vzip2_s8\", rettype = \"int8x8_t\", argtypes = \"[int8x8_t,int8x8_t]\", vals = [VectorVal [IntegerVal 127,IntegerVal (-18),IntegerVal 0,IntegerVal 0,IntegerVal (-1),IntegerVal (-128),IntegerVal (-4),IntegerVal 0],VectorVal [IntegerVal (-1),IntegerVal 127,IntegerVal 127,IntegerVal 127,IntegerVal 127,IntegerVal (-17),IntegerVal (-124),IntegerVal (-128)]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s8(UINT64_C(0x00fc80ff0000ee7f));
      arg2 = vcreate_s8(UINT64_C(0x8084ef7f7f7f7fff));
      clear_neon_saturated();
      //  Expect: "result" = 800084fcef807fff
      result = vzip2_s8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s8(result), 0);
      exp = UINT64_C(0x800084fcef807fff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_3140() {

{
   {
      int16x4_t arg1;
      int16x4_t arg2;
      int16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"zip1\", fnname = \"vzip1_s16\", rettype = \"int16x4_t\", argtypes = \"[int16x4_t,int16x4_t]\", vals = [VectorVal [IntegerVal 21488,IntegerVal (-32768),IntegerVal (-32768),IntegerVal (-26010)],VectorVal [IntegerVal 13303,IntegerVal (-32768),IntegerVal 32767,IntegerVal 0]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s16(UINT64_C(0x9a668000800053f0));
      arg2 = vcreate_s16(UINT64_C(0x00007fff800033f7));
      clear_neon_saturated();
      //  Expect: "result" = 8000800033f753f0
      result = vzip1_s16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s16(result), 0);
      exp = UINT64_C(0x8000800033f753f0);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_3141() {

{
   {
      int16x4_t arg1;
      int16x4_t arg2;
      int16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"zip2\", fnname = \"vzip2_s16\", rettype = \"int16x4_t\", argtypes = \"[int16x4_t,int16x4_t]\", vals = [VectorVal [IntegerVal 32767,IntegerVal 32767,IntegerVal (-8048),IntegerVal 14046],VectorVal [IntegerVal 32767,IntegerVal 32767,IntegerVal (-1577),IntegerVal (-32768)]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s16(UINT64_C(0x36dee0907fff7fff));
      arg2 = vcreate_s16(UINT64_C(0x8000f9d77fff7fff));
      clear_neon_saturated();
      //  Expect: "result" = 800036def9d7e090
      result = vzip2_s16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s16(result), 0);
      exp = UINT64_C(0x800036def9d7e090);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_3142() {

{
   {
      int32x2_t arg1;
      int32x2_t arg2;
      int32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"zip1\", fnname = \"vzip1_s32\", rettype = \"int32x2_t\", argtypes = \"[int32x2_t,int32x2_t]\", vals = [VectorVal [IntegerVal 2147434314,IntegerVal (-2147483648)],VectorVal [IntegerVal 56926,IntegerVal 2147483647]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s32(UINT64_C(0x800000007fff3f4a));
      arg2 = vcreate_s32(UINT64_C(0x7fffffff0000de5e));
      clear_neon_saturated();
      //  Expect: "result" = 0000de5e7fff3f4a
      result = vzip1_s32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s32(result), 0);
      exp = UINT64_C(0x0000de5e7fff3f4a);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_3143() {

{
   {
      int32x2_t arg1;
      int32x2_t arg2;
      int32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"zip2\", fnname = \"vzip2_s32\", rettype = \"int32x2_t\", argtypes = \"[int32x2_t,int32x2_t]\", vals = [VectorVal [IntegerVal (-32768),IntegerVal (-1433)],VectorVal [IntegerVal 2147450879,IntegerVal 32768]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s32(UINT64_C(0xfffffa67ffff8000));
      arg2 = vcreate_s32(UINT64_C(0x000080007fff7fff));
      clear_neon_saturated();
      //  Expect: "result" = 00008000fffffa67
      result = vzip2_s32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s32(result), 0);
      exp = UINT64_C(0x00008000fffffa67);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_3144() {

{
   {
      uint8x8_t arg1;
      uint8x8_t arg2;
      uint8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"zip1\", fnname = \"vzip1_u8\", rettype = \"uint8x8_t\", argtypes = \"[uint8x8_t,uint8x8_t]\", vals = [VectorVal [IntegerVal 0,IntegerVal 0,IntegerVal 0,IntegerVal 255,IntegerVal 0,IntegerVal 128,IntegerVal 127,IntegerVal 44],VectorVal [IntegerVal 255,IntegerVal 0,IntegerVal 128,IntegerVal 127,IntegerVal 255,IntegerVal 0,IntegerVal 255,IntegerVal 0]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u8(UINT64_C(0x2c7f8000ff000000));
      arg2 = vcreate_u8(UINT64_C(0x00ff00ff7f8000ff));
      clear_neon_saturated();
      //  Expect: "result" = 7fff80000000ff00
      result = vzip1_u8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u8(result), 0);
      exp = UINT64_C(0x7fff80000000ff00);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_3145() {

{
   {
      uint8x8_t arg1;
      uint8x8_t arg2;
      uint8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"zip2\", fnname = \"vzip2_u8\", rettype = \"uint8x8_t\", argtypes = \"[uint8x8_t,uint8x8_t]\", vals = [VectorVal [IntegerVal 255,IntegerVal 0,IntegerVal 198,IntegerVal 0,IntegerVal 255,IntegerVal 255,IntegerVal 0,IntegerVal 255],VectorVal [IntegerVal 128,IntegerVal 0,IntegerVal 127,IntegerVal 0,IntegerVal 127,IntegerVal 127,IntegerVal 127,IntegerVal 128]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u8(UINT64_C(0xff00ffff00c600ff));
      arg2 = vcreate_u8(UINT64_C(0x807f7f7f007f0080));
      clear_neon_saturated();
      //  Expect: "result" = 80ff7f007fff7fff
      result = vzip2_u8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u8(result), 0);
      exp = UINT64_C(0x80ff7f007fff7fff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_3146() {

{
   {
      uint16x4_t arg1;
      uint16x4_t arg2;
      uint16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"zip1\", fnname = \"vzip1_u16\", rettype = \"uint16x4_t\", argtypes = \"[uint16x4_t,uint16x4_t]\", vals = [VectorVal [IntegerVal 32767,IntegerVal 8487,IntegerVal 50529,IntegerVal 32768],VectorVal [IntegerVal 0,IntegerVal 65535,IntegerVal 0,IntegerVal 37917]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u16(UINT64_C(0x8000c56121277fff));
      arg2 = vcreate_u16(UINT64_C(0x941d0000ffff0000));
      clear_neon_saturated();
      //  Expect: "result" = ffff212700007fff
      result = vzip1_u16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u16(result), 0);
      exp = UINT64_C(0xffff212700007fff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_3147() {

{
   {
      uint16x4_t arg1;
      uint16x4_t arg2;
      uint16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"zip2\", fnname = \"vzip2_u16\", rettype = \"uint16x4_t\", argtypes = \"[uint16x4_t,uint16x4_t]\", vals = [VectorVal [IntegerVal 40374,IntegerVal 32768,IntegerVal 32768,IntegerVal 32768],VectorVal [IntegerVal 45784,IntegerVal 0,IntegerVal 0,IntegerVal 32768]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u16(UINT64_C(0x8000800080009db6));
      arg2 = vcreate_u16(UINT64_C(0x800000000000b2d8));
      clear_neon_saturated();
      //  Expect: "result" = 8000800000008000
      result = vzip2_u16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u16(result), 0);
      exp = UINT64_C(0x8000800000008000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_3148() {

{
   {
      uint32x2_t arg1;
      uint32x2_t arg2;
      uint32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"zip1\", fnname = \"vzip1_u32\", rettype = \"uint32x2_t\", argtypes = \"[uint32x2_t,uint32x2_t]\", vals = [VectorVal [IntegerVal 4294934527,IntegerVal 784245055],VectorVal [IntegerVal 2147549183,IntegerVal 65535]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u32(UINT64_C(0x2ebea13fffff7fff));
      arg2 = vcreate_u32(UINT64_C(0x0000ffff8000ffff));
      clear_neon_saturated();
      //  Expect: "result" = 8000ffffffff7fff
      result = vzip1_u32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u32(result), 0);
      exp = UINT64_C(0x8000ffffffff7fff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_3149() {

{
   {
      uint32x2_t arg1;
      uint32x2_t arg2;
      uint32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"zip2\", fnname = \"vzip2_u32\", rettype = \"uint32x2_t\", argtypes = \"[uint32x2_t,uint32x2_t]\", vals = [VectorVal [IntegerVal 314348862,IntegerVal 3206217728],VectorVal [IntegerVal 4294962430,IntegerVal 2147450880]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u32(UINT64_C(0xbf1b000012bc953e));
      arg2 = vcreate_u32(UINT64_C(0x7fff8000ffffecfe));
      clear_neon_saturated();
      //  Expect: "result" = 7fff8000bf1b0000
      result = vzip2_u32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u32(result), 0);
      exp = UINT64_C(0x7fff8000bf1b0000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_3150() {

{
   {
      poly8x8_t arg1;
      poly8x8_t arg2;
      poly8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"zip1\", fnname = \"vzip1_p8\", rettype = \"poly8x8_t\", argtypes = \"[poly8x8_t,poly8x8_t]\", vals = [VectorVal [PolyVal [1,1,1,1,0,1,1,1],PolyVal [0,1,0,0,0,0,1,1],PolyVal [1,0,0,1,0,0,1,1],PolyVal [1,0,1,0,0,0,0,1],PolyVal [0,0,1,1,0,0,1,1],PolyVal [1,1,0,0,0,0,1,0],PolyVal [1,0,1,1,1,0,0,1],PolyVal [1,0,0,1,1,1,0,1]],VectorVal [PolyVal [1,0,1,1,0,0,1,1],PolyVal [1,0,0,1,0,0,0,1],PolyVal [1,0,0,0,1,1,1,1],PolyVal [1,0,0,0,1,1,0,1],PolyVal [1,1,0,0,0,1,1,0],PolyVal [1,0,1,1,1,0,0,0],PolyVal [1,0,1,1,1,1,0,0],PolyVal [1,1,0,0,0,0,1,1]]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_p8(UINT64_C(0xb99d43cc85c9c2ef));
      arg2 = vcreate_p8(UINT64_C(0xc33d1d63b1f189cd));
      clear_neon_saturated();
      //  Expect: "result" = b185f1c989c2cdef
      result = vzip1_p8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_p8(result), 0);
      exp = UINT64_C(0xb185f1c989c2cdef);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_3151() {

{
   {
      poly8x8_t arg1;
      poly8x8_t arg2;
      poly8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"zip2\", fnname = \"vzip2_p8\", rettype = \"poly8x8_t\", argtypes = \"[poly8x8_t,poly8x8_t]\", vals = [VectorVal [PolyVal [0,1,0,1,1,1,1,0],PolyVal [0,1,0,1,0,1,1,0],PolyVal [0,1,1,1,1,0,1,0],PolyVal [0,1,1,1,1,1,1,1],PolyVal [1,1,0,1,0,1,0,1],PolyVal [0,1,0,1,1,0,1,0],PolyVal [0,1,0,1,0,0,1,1],PolyVal [1,0,1,1,1,1,0,0]],VectorVal [PolyVal [1,0,0,1,1,1,0,0],PolyVal [1,0,0,1,1,1,0,1],PolyVal [0,0,1,0,1,0,1,1],PolyVal [1,0,1,1,1,0,0,1],PolyVal [0,1,1,0,1,1,0,1],PolyVal [0,1,1,0,1,1,1,0],PolyVal [1,1,1,0,0,0,1,1],PolyVal [0,1,1,1,1,0,0,0]]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_p8(UINT64_C(0x3dca5aabfe5e6a7a));
      arg2 = vcreate_p8(UINT64_C(0x1ec776b69dd4b939));
      clear_neon_saturated();
      //  Expect: "result" = 1e3dc7ca765ab6ab
      result = vzip2_p8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_p8(result), 0);
      exp = UINT64_C(0x1e3dc7ca765ab6ab);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_3152() {

{
   {
      poly16x4_t arg1;
      poly16x4_t arg2;
      poly16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"zip1\", fnname = \"vzip1_p16\", rettype = \"poly16x4_t\", argtypes = \"[poly16x4_t,poly16x4_t]\", vals = [VectorVal [PolyVal [1,1,0,1,0,1,0,1,1,1,0,1,0,1,1,0],PolyVal [0,0,0,1,0,1,1,0,1,0,0,0,1,1,0,0],PolyVal [1,0,1,0,1,0,1,1,0,0,1,1,0,0,1,1],PolyVal [0,1,0,1,0,0,0,0,0,0,1,0,1,1,0,1]],VectorVal [PolyVal [0,1,1,1,1,0,1,0,0,1,0,0,1,0,0,1],PolyVal [1,0,1,0,1,0,1,0,1,0,1,1,1,0,1,0],PolyVal [0,0,0,1,1,1,1,1,1,0,1,0,1,1,0,1],PolyVal [1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1]]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_p16(UINT64_C(0xb40accd531686bab));
      arg2 = vcreate_p16(UINT64_C(0x9081b5f85d55925e));
      clear_neon_saturated();
      //  Expect: "result" = 5d553168925e6bab
      result = vzip1_p16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_p16(result), 0);
      exp = UINT64_C(0x5d553168925e6bab);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_3153() {

{
   {
      poly16x4_t arg1;
      poly16x4_t arg2;
      poly16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"zip2\", fnname = \"vzip2_p16\", rettype = \"poly16x4_t\", argtypes = \"[poly16x4_t,poly16x4_t]\", vals = [VectorVal [PolyVal [1,0,0,0,1,0,0,0,1,0,1,1,1,0,1,1],PolyVal [0,0,0,0,0,0,1,1,0,1,1,1,1,1,0,0],PolyVal [1,1,1,0,0,1,0,0,0,1,0,0,1,1,1,1],PolyVal [0,0,1,1,0,1,0,0,0,1,0,0,0,0,1,0]],VectorVal [PolyVal [0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,1],PolyVal [0,1,1,1,1,1,1,1,1,0,1,0,1,1,1,0],PolyVal [0,0,0,0,0,1,1,0,1,1,0,1,1,1,0,0],PolyVal [1,0,0,1,0,1,0,1,1,0,1,1,0,1,1,1]]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_p16(UINT64_C(0x422cf2273ec0dd11));
      arg2 = vcreate_p16(UINT64_C(0xeda93b6075fe80a4));
      clear_neon_saturated();
      //  Expect: "result" = eda9422c3b60f227
      result = vzip2_p16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_p16(result), 0);
      exp = UINT64_C(0xeda9422c3b60f227);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_3154() {

{
   {
      float32x2_t arg1;
      float32x2_t arg2;
      float32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"zip1\", fnname = \"vzip1_f32\", rettype = \"float32x2_t\", argtypes = \"[float32x2_t,float32x2_t]\", vals = [VectorVal [FloatVal 0.5867176055908203,FloatVal 0.4846867322921753],VectorVal [FloatVal 0.3151947259902954,FloatVal 0.6921705603599548]], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_f32(UINT64_C(0x3ef828dc3f163320));
      arg2 = vcreate_f32(UINT64_C(0x3f3132173ea16134));
      clear_neon_saturated();
      //  Expect: "result" = 3ea161343f163320
      result = vzip1_f32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result, 0);
         exp = ((float32_t) 0.5867176055908203);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result, 1);
         exp = ((float32_t) 0.3151947259902954);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
   }
}
}
void dotests_3155() {

{
   {
      float32x2_t arg1;
      float32x2_t arg2;
      float32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"zip2\", fnname = \"vzip2_f32\", rettype = \"float32x2_t\", argtypes = \"[float32x2_t,float32x2_t]\", vals = [VectorVal [FloatVal 0.8540856242179871,FloatVal 0.3300197720527649],VectorVal [FloatVal 0.8682851195335388,FloatVal 0.5784477591514587]], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_f32(UINT64_C(0x3ea8f85a3f5aa55b));
      arg2 = vcreate_f32(UINT64_C(0x3f1415273f5e47ef));
      clear_neon_saturated();
      //  Expect: "result" = 3f1415273ea8f85a
      result = vzip2_f32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result, 0);
         exp = ((float32_t) 0.3300197720527649);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result, 1);
         exp = ((float32_t) 0.5784477591514587);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
   }
}
}
void dotests_3156() {

{
   {
      int8x16_t arg1;
      int8x16_t arg2;
      int8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"zip1\", fnname = \"vzip1q_s8\", rettype = \"int8x16_t\", argtypes = \"[int8x16_t,int8x16_t]\", vals = [VectorVal [IntegerVal 127,IntegerVal (-58),IntegerVal (-90),IntegerVal 90,IntegerVal (-128),IntegerVal (-1),IntegerVal 127,IntegerVal 0,IntegerVal 0,IntegerVal (-1),IntegerVal 127,IntegerVal (-70),IntegerVal 127,IntegerVal (-1),IntegerVal (-128),IntegerVal (-128)],VectorVal [IntegerVal (-9),IntegerVal (-1),IntegerVal 0,IntegerVal 127,IntegerVal (-1),IntegerVal (-128),IntegerVal 0,IntegerVal (-103),IntegerVal (-1),IntegerVal 127,IntegerVal 54,IntegerVal 36,IntegerVal (-1),IntegerVal (-1),IntegerVal 79,IntegerVal 127]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s8(vcreate_s8(UINT64_C(0x007fff805aa6c67f)),
                         vcreate_s8(UINT64_C(0x8080ff7fba7fff00)));
      arg2 = vcombine_s8(vcreate_s8(UINT64_C(0x990080ff7f00fff7)),
                         vcreate_s8(UINT64_C(0x7f4fffff24367fff)));
      clear_neon_saturated();
      //  Expect: "result" = 9900007f80ffff807f5a00a6ffc6f77f
      result = vzip1q_s8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result), 0);
         exp = UINT64_C(0x7f5a00a6ffc6f77f);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result), 1);
         exp = UINT64_C(0x9900007f80ffff80);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_3157() {

{
   {
      int8x16_t arg1;
      int8x16_t arg2;
      int8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"zip2\", fnname = \"vzip2q_s8\", rettype = \"int8x16_t\", argtypes = \"[int8x16_t,int8x16_t]\", vals = [VectorVal [IntegerVal 0,IntegerVal (-128),IntegerVal 0,IntegerVal (-94),IntegerVal (-128),IntegerVal (-1),IntegerVal 0,IntegerVal (-128),IntegerVal (-1),IntegerVal 108,IntegerVal 127,IntegerVal 59,IntegerVal 127,IntegerVal (-82),IntegerVal (-7),IntegerVal 0],VectorVal [IntegerVal 0,IntegerVal (-128),IntegerVal (-1),IntegerVal 127,IntegerVal (-95),IntegerVal (-1),IntegerVal 127,IntegerVal (-1),IntegerVal 0,IntegerVal 0,IntegerVal (-128),IntegerVal 0,IntegerVal 0,IntegerVal 0,IntegerVal (-128),IntegerVal 42]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s8(vcreate_s8(UINT64_C(0x8000ff80a2008000)),
                         vcreate_s8(UINT64_C(0x00f9ae7f3b7f6cff)));
      arg2 = vcombine_s8(vcreate_s8(UINT64_C(0xff7fffa17fff8000)),
                         vcreate_s8(UINT64_C(0x2a80000000800000)));
      clear_neon_saturated();
      //  Expect: "result" = 2a0080f900ae007f003b807f006c00ff
      result = vzip2q_s8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result), 0);
         exp = UINT64_C(0x003b807f006c00ff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result), 1);
         exp = UINT64_C(0x2a0080f900ae007f);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_3158() {

{
   {
      int16x8_t arg1;
      int16x8_t arg2;
      int16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"zip1\", fnname = \"vzip1q_s16\", rettype = \"int16x8_t\", argtypes = \"[int16x8_t,int16x8_t]\", vals = [VectorVal [IntegerVal (-32768),IntegerVal 32767,IntegerVal (-32768),IntegerVal 0,IntegerVal (-30162),IntegerVal 32767,IntegerVal (-1),IntegerVal (-32768)],VectorVal [IntegerVal 32767,IntegerVal 0,IntegerVal (-1),IntegerVal 0,IntegerVal 0,IntegerVal (-32768),IntegerVal (-32768),IntegerVal (-32768)]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s16(vcreate_s16(UINT64_C(0x000080007fff8000)),
                          vcreate_s16(UINT64_C(0x8000ffff7fff8a2e)));
      arg2 = vcombine_s16(vcreate_s16(UINT64_C(0x0000ffff00007fff)),
                          vcreate_s16(UINT64_C(0x8000800080000000)));
      clear_neon_saturated();
      //  Expect: "result" = 00000000ffff800000007fff7fff8000
      result = vzip1q_s16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 0);
         exp = UINT64_C(0x00007fff7fff8000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 1);
         exp = UINT64_C(0x00000000ffff8000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_3159() {

{
   {
      int16x8_t arg1;
      int16x8_t arg2;
      int16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"zip2\", fnname = \"vzip2q_s16\", rettype = \"int16x8_t\", argtypes = \"[int16x8_t,int16x8_t]\", vals = [VectorVal [IntegerVal (-32768),IntegerVal 0,IntegerVal 32767,IntegerVal 0,IntegerVal 0,IntegerVal (-10472),IntegerVal (-1),IntegerVal 32767],VectorVal [IntegerVal 32767,IntegerVal 0,IntegerVal 0,IntegerVal (-32768),IntegerVal 0,IntegerVal 24066,IntegerVal 32764,IntegerVal 32767]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s16(vcreate_s16(UINT64_C(0x00007fff00008000)),
                          vcreate_s16(UINT64_C(0x7fffffffd7180000)));
      arg2 = vcombine_s16(vcreate_s16(UINT64_C(0x8000000000007fff)),
                          vcreate_s16(UINT64_C(0x7fff7ffc5e020000)));
      clear_neon_saturated();
      //  Expect: "result" = 7fff7fff7ffcffff5e02d71800000000
      result = vzip2q_s16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 0);
         exp = UINT64_C(0x5e02d71800000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 1);
         exp = UINT64_C(0x7fff7fff7ffcffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_3160() {

{
   {
      int32x4_t arg1;
      int32x4_t arg2;
      int32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"zip1\", fnname = \"vzip1q_s32\", rettype = \"int32x4_t\", argtypes = \"[int32x4_t,int32x4_t]\", vals = [VectorVal [IntegerVal (-32768),IntegerVal (-2147483648),IntegerVal 32768,IntegerVal (-153518080)],VectorVal [IntegerVal 2147483647,IntegerVal 1483177984,IntegerVal (-2147427232),IntegerVal (-32769)]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s32(vcreate_s32(UINT64_C(0x80000000ffff8000)),
                          vcreate_s32(UINT64_C(0xf6d9800000008000)));
      arg2 = vcombine_s32(vcreate_s32(UINT64_C(0x586780007fffffff)),
                          vcreate_s32(UINT64_C(0xffff7fff8000dc60)));
      clear_neon_saturated();
      //  Expect: "result" = 58678000800000007fffffffffff8000
      result = vzip1q_s32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 0);
         exp = UINT64_C(0x7fffffffffff8000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 1);
         exp = UINT64_C(0x5867800080000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_3161() {

{
   {
      int32x4_t arg1;
      int32x4_t arg2;
      int32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"zip2\", fnname = \"vzip2q_s32\", rettype = \"int32x4_t\", argtypes = \"[int32x4_t,int32x4_t]\", vals = [VectorVal [IntegerVal 32768,IntegerVal 35827,IntegerVal 32767,IntegerVal 2147450879],VectorVal [IntegerVal 65535,IntegerVal (-1033273345),IntegerVal (-1),IntegerVal 2147450879]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s32(vcreate_s32(UINT64_C(0x00008bf300008000)),
                          vcreate_s32(UINT64_C(0x7fff7fff00007fff)));
      arg2 = vcombine_s32(vcreate_s32(UINT64_C(0xc2697fff0000ffff)),
                          vcreate_s32(UINT64_C(0x7fff7fffffffffff)));
      clear_neon_saturated();
      //  Expect: "result" = 7fff7fff7fff7fffffffffff00007fff
      result = vzip2q_s32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 0);
         exp = UINT64_C(0xffffffff00007fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 1);
         exp = UINT64_C(0x7fff7fff7fff7fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_3162() {

{
   {
      int64x2_t arg1;
      int64x2_t arg2;
      int64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"zip1\", fnname = \"vzip1q_s64\", rettype = \"int64x2_t\", argtypes = \"[int64x2_t,int64x2_t]\", vals = [VectorVal [IntegerVal 5826813492887322624,IntegerVal 9223335488830603263],VectorVal [IntegerVal 129059472301628,IntegerVal (-1143632832522823157)]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s64(vcreate_s64(UINT64_C(0x50dd000000008000)),
                          vcreate_s64(UINT64_C(0x7fffdec280007fff)));
      arg2 = vcombine_s64(vcreate_s64(UINT64_C(0x0000756100005e3c)),
                          vcreate_s64(UINT64_C(0xf020ffff8000da0b)));
      clear_neon_saturated();
      //  Expect: "result" = 0000756100005e3c50dd000000008000
      result = vzip1q_s64(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 0);
         exp = UINT64_C(0x50dd000000008000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 1);
         exp = UINT64_C(0x0000756100005e3c);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_3163() {

{
   {
      int64x2_t arg1;
      int64x2_t arg2;
      int64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"zip2\", fnname = \"vzip2q_s64\", rettype = \"int64x2_t\", argtypes = \"[int64x2_t,int64x2_t]\", vals = [VectorVal [IntegerVal 9223231301513838592,IntegerVal 5547449580649424749],VectorVal [IntegerVal 9223231299366420479,IntegerVal 8416383280772774294]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s64(vcreate_s64(UINT64_C(0x7fff80007fff0000)),
                          vcreate_s64(UINT64_C(0x4cfc80007fffa76d)));
      arg2 = vcombine_s64(vcreate_s64(UINT64_C(0x7fff7fffffffffff)),
                          vcreate_s64(UINT64_C(0x74cd00007fff7996)));
      clear_neon_saturated();
      //  Expect: "result" = 74cd00007fff79964cfc80007fffa76d
      result = vzip2q_s64(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 0);
         exp = UINT64_C(0x4cfc80007fffa76d);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 1);
         exp = UINT64_C(0x74cd00007fff7996);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_3164() {

{
   {
      uint8x16_t arg1;
      uint8x16_t arg2;
      uint8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"zip1\", fnname = \"vzip1q_u8\", rettype = \"uint8x16_t\", argtypes = \"[uint8x16_t,uint8x16_t]\", vals = [VectorVal [IntegerVal 255,IntegerVal 255,IntegerVal 205,IntegerVal 128,IntegerVal 60,IntegerVal 162,IntegerVal 128,IntegerVal 0,IntegerVal 255,IntegerVal 131,IntegerVal 127,IntegerVal 127,IntegerVal 255,IntegerVal 84,IntegerVal 0,IntegerVal 127],VectorVal [IntegerVal 128,IntegerVal 127,IntegerVal 128,IntegerVal 255,IntegerVal 255,IntegerVal 255,IntegerVal 255,IntegerVal 255,IntegerVal 85,IntegerVal 255,IntegerVal 255,IntegerVal 23,IntegerVal 121,IntegerVal 44,IntegerVal 0,IntegerVal 250]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u8(vcreate_u8(UINT64_C(0x0080a23c80cdffff)),
                         vcreate_u8(UINT64_C(0x7f0054ff7f7f83ff)));
      arg2 = vcombine_u8(vcreate_u8(UINT64_C(0xffffffffff807f80)),
                         vcreate_u8(UINT64_C(0xfa002c7917ffff55)));
      clear_neon_saturated();
      //  Expect: "result" = ff00ff80ffa2ff3cff8080cd7fff80ff
      result = vzip1q_u8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 0);
         exp = UINT64_C(0xff8080cd7fff80ff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 1);
         exp = UINT64_C(0xff00ff80ffa2ff3c);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_3165() {

{
   {
      uint8x16_t arg1;
      uint8x16_t arg2;
      uint8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"zip2\", fnname = \"vzip2q_u8\", rettype = \"uint8x16_t\", argtypes = \"[uint8x16_t,uint8x16_t]\", vals = [VectorVal [IntegerVal 135,IntegerVal 128,IntegerVal 127,IntegerVal 127,IntegerVal 0,IntegerVal 128,IntegerVal 255,IntegerVal 127,IntegerVal 255,IntegerVal 0,IntegerVal 255,IntegerVal 0,IntegerVal 0,IntegerVal 255,IntegerVal 128,IntegerVal 254],VectorVal [IntegerVal 55,IntegerVal 127,IntegerVal 156,IntegerVal 127,IntegerVal 132,IntegerVal 59,IntegerVal 0,IntegerVal 255,IntegerVal 255,IntegerVal 0,IntegerVal 0,IntegerVal 127,IntegerVal 0,IntegerVal 0,IntegerVal 127,IntegerVal 255]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u8(vcreate_u8(UINT64_C(0x7fff80007f7f8087)),
                         vcreate_u8(UINT64_C(0xfe80ff0000ff00ff)));
      arg2 = vcombine_u8(vcreate_u8(UINT64_C(0xff003b847f9c7f37)),
                         vcreate_u8(UINT64_C(0xff7f00007f0000ff)));
      clear_neon_saturated();
      //  Expect: "result" = fffe7f8000ff00007f0000ff0000ffff
      result = vzip2q_u8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 0);
         exp = UINT64_C(0x7f0000ff0000ffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 1);
         exp = UINT64_C(0xfffe7f8000ff0000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_3166() {

{
   {
      uint16x8_t arg1;
      uint16x8_t arg2;
      uint16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"zip1\", fnname = \"vzip1q_u16\", rettype = \"uint16x8_t\", argtypes = \"[uint16x8_t,uint16x8_t]\", vals = [VectorVal [IntegerVal 65535,IntegerVal 32768,IntegerVal 32768,IntegerVal 32767,IntegerVal 32768,IntegerVal 32767,IntegerVal 32768,IntegerVal 0],VectorVal [IntegerVal 32725,IntegerVal 0,IntegerVal 65535,IntegerVal 32768,IntegerVal 65535,IntegerVal 32768,IntegerVal 32768,IntegerVal 0]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u16(vcreate_u16(UINT64_C(0x7fff80008000ffff)),
                          vcreate_u16(UINT64_C(0x000080007fff8000)));
      arg2 = vcombine_u16(vcreate_u16(UINT64_C(0x8000ffff00007fd5)),
                          vcreate_u16(UINT64_C(0x000080008000ffff)));
      clear_neon_saturated();
      //  Expect: "result" = 80007fffffff8000000080007fd5ffff
      result = vzip1q_u16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 0);
         exp = UINT64_C(0x000080007fd5ffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 1);
         exp = UINT64_C(0x80007fffffff8000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_3167() {

{
   {
      uint16x8_t arg1;
      uint16x8_t arg2;
      uint16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"zip2\", fnname = \"vzip2q_u16\", rettype = \"uint16x8_t\", argtypes = \"[uint16x8_t,uint16x8_t]\", vals = [VectorVal [IntegerVal 38220,IntegerVal 0,IntegerVal 0,IntegerVal 45995,IntegerVal 32767,IntegerVal 65535,IntegerVal 65535,IntegerVal 32768],VectorVal [IntegerVal 12776,IntegerVal 32767,IntegerVal 0,IntegerVal 32767,IntegerVal 65535,IntegerVal 57835,IntegerVal 54749,IntegerVal 32768]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u16(vcreate_u16(UINT64_C(0xb3ab00000000954c)),
                          vcreate_u16(UINT64_C(0x8000ffffffff7fff)));
      arg2 = vcombine_u16(vcreate_u16(UINT64_C(0x7fff00007fff31e8)),
                          vcreate_u16(UINT64_C(0x8000d5dde1ebffff)));
      clear_neon_saturated();
      //  Expect: "result" = 80008000d5ddffffe1ebffffffff7fff
      result = vzip2q_u16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 0);
         exp = UINT64_C(0xe1ebffffffff7fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 1);
         exp = UINT64_C(0x80008000d5ddffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_3168() {

{
   {
      uint32x4_t arg1;
      uint32x4_t arg2;
      uint32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"zip1\", fnname = \"vzip1q_u32\", rettype = \"uint32x4_t\", argtypes = \"[uint32x4_t,uint32x4_t]\", vals = [VectorVal [IntegerVal 32768,IntegerVal 2147450879,IntegerVal 2147418112,IntegerVal 2147516415],VectorVal [IntegerVal 2147516415,IntegerVal 2147450880,IntegerVal 4294934528,IntegerVal 2147538042]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u32(vcreate_u32(UINT64_C(0x7fff7fff00008000)),
                          vcreate_u32(UINT64_C(0x80007fff7fff0000)));
      arg2 = vcombine_u32(vcreate_u32(UINT64_C(0x7fff800080007fff)),
                          vcreate_u32(UINT64_C(0x8000d47affff8000)));
      clear_neon_saturated();
      //  Expect: "result" = 7fff80007fff7fff80007fff00008000
      result = vzip1q_u32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 0);
         exp = UINT64_C(0x80007fff00008000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 1);
         exp = UINT64_C(0x7fff80007fff7fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_3169() {

{
   {
      uint32x4_t arg1;
      uint32x4_t arg2;
      uint32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"zip2\", fnname = \"vzip2q_u32\", rettype = \"uint32x4_t\", argtypes = \"[uint32x4_t,uint32x4_t]\", vals = [VectorVal [IntegerVal 2147549183,IntegerVal 2147450880,IntegerVal 2147459939,IntegerVal 951910400],VectorVal [IntegerVal 2147483648,IntegerVal 4294901760,IntegerVal 50482,IntegerVal 65535]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u32(vcreate_u32(UINT64_C(0x7fff80008000ffff)),
                          vcreate_u32(UINT64_C(0x38bd00007fffa363)));
      arg2 = vcombine_u32(vcreate_u32(UINT64_C(0xffff000080000000)),
                          vcreate_u32(UINT64_C(0x0000ffff0000c532)));
      clear_neon_saturated();
      //  Expect: "result" = 0000ffff38bd00000000c5327fffa363
      result = vzip2q_u32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 0);
         exp = UINT64_C(0x0000c5327fffa363);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 1);
         exp = UINT64_C(0x0000ffff38bd0000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_3170() {

{
   {
      uint64x2_t arg1;
      uint64x2_t arg2;
      uint64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"zip1\", fnname = \"vzip1q_u64\", rettype = \"uint64x2_t\", argtypes = \"[uint64x2_t,uint64x2_t]\", vals = [VectorVal [IntegerVal 18446603333874089983,IntegerVal 9223372034707324928],VectorVal [IntegerVal 18446744073709518848,IntegerVal 18446603332061999263]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u64(vcreate_u64(UINT64_C(0xffff7fff7419ffff)),
                          vcreate_u64(UINT64_C(0x7fffffff80008000)));
      arg2 = vcombine_u64(vcreate_u64(UINT64_C(0xffffffffffff8000)),
                          vcreate_u64(UINT64_C(0xffff7fff0817b09f)));
      clear_neon_saturated();
      //  Expect: "result" = ffffffffffff8000ffff7fff7419ffff
      result = vzip1q_u64(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 0);
         exp = UINT64_C(0xffff7fff7419ffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 1);
         exp = UINT64_C(0xffffffffffff8000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_3171() {

{
   {
      uint64x2_t arg1;
      uint64x2_t arg2;
      uint64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"zip2\", fnname = \"vzip2q_u64\", rettype = \"uint64x2_t\", argtypes = \"[uint64x2_t,uint64x2_t]\", vals = [VectorVal [IntegerVal 9223372040736210944,IntegerVal 9223512772195713023],VectorVal [IntegerVal 9223512772195662504,IntegerVal 18446462598732906495]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u64(vcreate_u64(UINT64_C(0x80000000e75a0000)),
                          vcreate_u64(UINT64_C(0x80007fff8000ffff)));
      arg2 = vcombine_u64(vcreate_u64(UINT64_C(0x80007fff80003aa8)),
                          vcreate_u64(UINT64_C(0xffff00000000ffff)));
      clear_neon_saturated();
      //  Expect: "result" = ffff00000000ffff80007fff8000ffff
      result = vzip2q_u64(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 0);
         exp = UINT64_C(0x80007fff8000ffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 1);
         exp = UINT64_C(0xffff00000000ffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_3172() {

{
   {
      poly8x16_t arg1;
      poly8x16_t arg2;
      poly8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"zip1\", fnname = \"vzip1q_p8\", rettype = \"poly8x16_t\", argtypes = \"[poly8x16_t,poly8x16_t]\", vals = [VectorVal [PolyVal [1,1,1,1,1,0,1,1],PolyVal [0,0,0,1,0,1,0,0],PolyVal [0,0,1,0,1,0,1,0],PolyVal [1,0,1,0,1,1,0,0],PolyVal [0,0,1,1,1,1,0,0],PolyVal [0,1,0,0,0,1,1,0],PolyVal [0,1,1,0,1,0,0,1],PolyVal [1,0,1,1,0,1,0,1],PolyVal [1,1,1,0,0,0,1,0],PolyVal [0,1,0,0,0,1,1,0],PolyVal [0,1,1,0,1,0,0,0],PolyVal [0,0,1,1,0,1,0,1],PolyVal [1,0,1,0,1,0,1,0],PolyVal [1,1,1,1,1,0,0,0],PolyVal [0,1,1,1,1,1,0,0],PolyVal [0,0,0,1,0,1,0,0]],VectorVal [PolyVal [1,0,1,0,1,1,0,1],PolyVal [1,1,0,1,0,1,0,1],PolyVal [0,1,1,1,1,0,1,0],PolyVal [1,0,0,1,1,1,1,0],PolyVal [0,1,1,1,1,1,0,0],PolyVal [1,1,1,1,1,0,1,0],PolyVal [1,1,0,0,1,1,1,0],PolyVal [1,0,0,1,1,1,1,1],PolyVal [1,1,1,1,1,1,0,1],PolyVal [0,1,1,1,1,0,0,0],PolyVal [0,0,0,1,1,1,1,0],PolyVal [1,1,1,0,1,0,1,0],PolyVal [0,1,1,1,1,0,1,1],PolyVal [0,1,0,0,0,1,0,1],PolyVal [0,0,1,0,0,0,1,0],PolyVal [1,0,1,1,0,1,1,0]]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_p8(vcreate_p8(UINT64_C(0xad96623c355428df)),
                         vcreate_p8(UINT64_C(0x283e1f55ac166247)));
      arg2 = vcombine_p8(vcreate_p8(UINT64_C(0xf9735f3e795eabb5)),
                         vcreate_p8(UINT64_C(0x6d44a2de57781ebf)));
      clear_neon_saturated();
      //  Expect: "result" = f9ad73965f623e3c79355e54ab28b5df
      result = vzip1q_p8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p8(result), 0);
         exp = UINT64_C(0x79355e54ab28b5df);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p8(result), 1);
         exp = UINT64_C(0xf9ad73965f623e3c);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_3173() {

{
   {
      poly8x16_t arg1;
      poly8x16_t arg2;
      poly8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"zip2\", fnname = \"vzip2q_p8\", rettype = \"poly8x16_t\", argtypes = \"[poly8x16_t,poly8x16_t]\", vals = [VectorVal [PolyVal [1,0,1,0,1,1,0,0],PolyVal [1,1,1,1,1,0,1,0],PolyVal [0,1,0,1,0,0,0,0],PolyVal [1,0,1,1,0,0,0,0],PolyVal [0,1,0,1,0,1,1,0],PolyVal [1,0,0,0,1,0,1,0],PolyVal [0,1,0,1,1,0,0,1],PolyVal [0,1,0,0,0,1,1,1],PolyVal [1,0,1,0,1,0,0,0],PolyVal [1,0,0,1,1,1,1,0],PolyVal [0,0,1,1,0,1,1,1],PolyVal [1,0,1,0,0,0,0,1],PolyVal [0,1,1,1,1,1,0,1],PolyVal [0,0,1,0,1,0,0,0],PolyVal [0,0,1,1,0,1,1,0],PolyVal [1,1,1,0,1,0,0,0]],VectorVal [PolyVal [0,1,1,1,0,1,1,0],PolyVal [0,1,1,1,0,1,0,0],PolyVal [1,0,1,1,0,0,1,1],PolyVal [0,0,1,1,1,1,0,0],PolyVal [1,1,0,1,0,0,0,0],PolyVal [0,1,1,1,1,0,1,1],PolyVal [1,0,1,1,0,0,1,0],PolyVal [0,0,0,0,0,1,0,0],PolyVal [0,0,0,1,0,1,0,0],PolyVal [0,1,1,1,0,1,0,0],PolyVal [0,0,0,1,1,0,0,1],PolyVal [0,0,0,1,0,0,1,1],PolyVal [0,0,1,0,1,1,1,1],PolyVal [0,1,1,1,0,1,0,1],PolyVal [0,0,1,1,1,1,1,1],PolyVal [0,0,0,1,1,0,1,1]]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_p8(vcreate_p8(UINT64_C(0xe29a516a0d0a5f35)),
                         vcreate_p8(UINT64_C(0x176c14be85ec7915)));
      arg2 = vcombine_p8(vcreate_p8(UINT64_C(0x204dde0b3ccd2e6e)),
                         vcreate_p8(UINT64_C(0xd8fcaef4c8982e28)));
      clear_neon_saturated();
      //  Expect: "result" = d817fc6cae14f4bec88598ec2e792815
      result = vzip2q_p8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p8(result), 0);
         exp = UINT64_C(0xc88598ec2e792815);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p8(result), 1);
         exp = UINT64_C(0xd817fc6cae14f4be);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_3174() {

{
   {
      poly16x8_t arg1;
      poly16x8_t arg2;
      poly16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"zip1\", fnname = \"vzip1q_p16\", rettype = \"poly16x8_t\", argtypes = \"[poly16x8_t,poly16x8_t]\", vals = [VectorVal [PolyVal [0,1,1,0,1,1,1,1,0,1,0,1,0,0,0,1],PolyVal [0,1,1,0,1,1,1,0,1,1,0,1,1,0,1,1],PolyVal [0,0,1,0,0,0,1,1,1,1,0,0,0,1,1,0],PolyVal [0,0,0,0,1,1,1,1,0,1,1,1,0,0,0,1],PolyVal [0,0,1,0,1,1,0,0,1,0,0,0,1,1,0,0],PolyVal [0,0,1,0,1,1,0,0,1,1,1,0,1,0,0,0],PolyVal [1,0,1,1,1,0,1,1,1,0,0,0,1,0,0,0],PolyVal [0,0,0,0,1,1,0,1,1,1,1,1,0,0,1,0]],VectorVal [PolyVal [0,0,0,0,0,1,0,1,1,1,1,0,1,0,1,1],PolyVal [1,0,0,0,1,0,1,1,0,0,0,0,1,1,1,1],PolyVal [0,0,0,1,1,1,0,1,0,1,1,1,1,1,1,0],PolyVal [0,1,1,0,1,0,0,0,1,1,1,1,0,0,0,0],PolyVal [0,1,1,0,1,1,1,0,1,0,0,1,1,1,0,1],PolyVal [1,0,0,1,0,1,1,1,0,1,0,0,0,0,0,0],PolyVal [1,1,0,0,1,1,1,1,0,1,1,0,0,1,0,0],PolyVal [0,0,0,1,1,1,1,0,0,0,1,1,0,1,1,0]]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_p16(vcreate_p16(UINT64_C(0x8ef063c4db768af6)),
                          vcreate_p16(UINT64_C(0x4fb011dd17343134)));
      arg2 = vcombine_p16(vcreate_p16(UINT64_C(0x0f167eb8f0d1d7a0)),
                          vcreate_p16(UINT64_C(0x6c7826f302e9b976)));
      clear_neon_saturated();
      //  Expect: "result" = 0f168ef07eb863c4f0d1db76d7a08af6
      result = vzip1q_p16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p16(result), 0);
         exp = UINT64_C(0xf0d1db76d7a08af6);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p16(result), 1);
         exp = UINT64_C(0x0f168ef07eb863c4);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_3175() {

{
   {
      poly16x8_t arg1;
      poly16x8_t arg2;
      poly16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"zip2\", fnname = \"vzip2q_p16\", rettype = \"poly16x8_t\", argtypes = \"[poly16x8_t,poly16x8_t]\", vals = [VectorVal [PolyVal [0,0,1,1,1,1,1,0,1,1,0,1,0,0,0,1],PolyVal [1,1,1,1,0,0,1,1,1,1,0,1,0,0,1,0],PolyVal [1,1,0,1,0,0,1,0,0,0,1,0,0,0,0,1],PolyVal [1,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0],PolyVal [0,1,0,0,0,0,1,0,0,0,1,1,1,1,0,1],PolyVal [1,0,1,1,0,0,1,1,1,0,0,1,0,1,0,0],PolyVal [0,1,0,0,1,1,0,0,0,1,0,0,1,1,1,0],PolyVal [0,1,1,1,1,1,0,0,0,0,1,0,0,1,1,0]],VectorVal [PolyVal [1,0,0,1,1,0,0,1,0,0,1,0,0,0,0,0],PolyVal [0,1,1,1,1,1,1,0,0,0,0,1,1,1,0,0],PolyVal [1,0,0,0,0,1,1,0,0,0,0,0,0,1,0,0],PolyVal [0,0,0,1,1,0,1,0,1,0,1,0,0,1,1,1],PolyVal [1,1,0,0,1,0,0,0,0,0,0,1,1,1,1,1],PolyVal [0,1,0,0,0,0,0,0,1,1,1,1,1,1,0,1],PolyVal [1,1,0,0,0,1,0,0,0,0,0,1,0,0,0,1],PolyVal [0,0,1,0,1,0,0,0,1,0,0,1,0,1,1,0]]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_p16(vcreate_p16(UINT64_C(0x1101844b4bcf8b7c)),
                          vcreate_p16(UINT64_C(0x643e723229cdbc42)));
      arg2 = vcombine_p16(vcreate_p16(UINT64_C(0xe5582061387e0499)),
                          vcreate_p16(UINT64_C(0x69148823bf02f813)));
      clear_neon_saturated();
      //  Expect: "result" = 6914643e88237232bf0229cdf813bc42
      result = vzip2q_p16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p16(result), 0);
         exp = UINT64_C(0xbf0229cdf813bc42);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p16(result), 1);
         exp = UINT64_C(0x6914643e88237232);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_3176() {

{
   {
      float32x4_t arg1;
      float32x4_t arg2;
      float32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"zip1\", fnname = \"vzip1q_f32\", rettype = \"float32x4_t\", argtypes = \"[float32x4_t,float32x4_t]\", vals = [VectorVal [FloatVal 0.37149327993392944,FloatVal 0.6832275390625,FloatVal 0.303907573223114,FloatVal 0.8899004459381104],VectorVal [FloatVal 0.7484279870986938,FloatVal 0.2941542863845825,FloatVal 0.3070300817489624,FloatVal 0.9078465104103088]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_f32(vcreate_f32(UINT64_C(0x3f2ee8003ebe345e)),
                          vcreate_f32(UINT64_C(0x3f63d0843e9b99c6)));
      arg2 = vcombine_f32(vcreate_f32(UINT64_C(0x3e969b643f3f98fa)),
                          vcreate_f32(UINT64_C(0x3f6868a13e9d330c)));
      clear_neon_saturated();
      //  Expect: "result" = 3e969b643f2ee8003f3f98fa3ebe345e
      result = vzip1q_f32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 0);
         exp = ((float32_t) 0.37149327993392944);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 1);
         exp = ((float32_t) 0.7484279870986938);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 2);
         exp = ((float32_t) 0.6832275390625);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 2 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 3);
         exp = ((float32_t) 0.2941542863845825);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 3 ", exp, got);
            }
      }
   }
}
}
void dotests_3177() {

{
   {
      float32x4_t arg1;
      float32x4_t arg2;
      float32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"zip2\", fnname = \"vzip2q_f32\", rettype = \"float32x4_t\", argtypes = \"[float32x4_t,float32x4_t]\", vals = [VectorVal [FloatVal 0.550042986869812,FloatVal 0.792776882648468,FloatVal 0.14767342805862427,FloatVal 0.539278507232666],VectorVal [FloatVal 0.9258381724357605,FloatVal 0.5994558930397034,FloatVal 0.761388897895813,FloatVal 0.7050647139549255]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_f32(vcreate_f32(UINT64_C(0x3f4af36d3f0ccf9e)),
                          vcreate_f32(UINT64_C(0x3f0a0e283e1737b4)));
      arg2 = vcombine_f32(vcreate_f32(UINT64_C(0x3f1975f13f6d03bb)),
                          vcreate_f32(UINT64_C(0x3f347f1f3f42ea62)));
      clear_neon_saturated();
      //  Expect: "result" = 3f347f1f3f0a0e283f42ea623e1737b4
      result = vzip2q_f32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 0);
         exp = ((float32_t) 0.14767342805862427);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 1);
         exp = ((float32_t) 0.761388897895813);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 2);
         exp = ((float32_t) 0.539278507232666);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 2 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 3);
         exp = ((float32_t) 0.7050647139549255);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 3 ", exp, got);
            }
      }
   }
}
}
void dotests_3178() {

{
   {
      float64x2_t arg1;
      float64x2_t arg2;
      float64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"zip1\", fnname = \"vzip1q_f64\", rettype = \"float64x2_t\", argtypes = \"[float64x2_t,float64x2_t]\", vals = [VectorVal [FloatVal 0.2889613276849692,FloatVal 0.5475423689039097],VectorVal [FloatVal 9.451065049571683e-2,FloatVal 0.552486477283869]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_f64(vcreate_f64(UINT64_C(0x3fd27e57a70dcdbc)),
                          vcreate_f64(UINT64_C(0x3fe1857792f3bbad)));
      arg2 = vcombine_f64(vcreate_f64(UINT64_C(0x3fb831d99900b6d8)),
                          vcreate_f64(UINT64_C(0x3fe1adf81eed53ad)));
      clear_neon_saturated();
      //  Expect: "result" = 3fb831d99900b6d83fd27e57a70dcdbc
      result = vzip1q_f64(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float64_t got;
         float64_t exp;
         got = vgetq_lane_f64(result, 0);
         exp = 0.2889613276849692;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float64_t got;
         float64_t exp;
         got = vgetq_lane_f64(result, 1);
         exp = 9.451065049571683e-2;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
   }
}
}
void dotests_3179() {

{
   {
      float64x2_t arg1;
      float64x2_t arg2;
      float64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"zip2\", fnname = \"vzip2q_f64\", rettype = \"float64x2_t\", argtypes = \"[float64x2_t,float64x2_t]\", vals = [VectorVal [FloatVal 0.814620978043535,FloatVal 0.6266044165979661],VectorVal [FloatVal 0.3191092697481337,FloatVal 0.7462845652626667]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_f64(vcreate_f64(UINT64_C(0x3fea1160036aa3fa)),
                          vcreate_f64(UINT64_C(0x3fe40d24b49a2856)));
      arg2 = vcombine_f64(vcreate_f64(UINT64_C(0x3fd46c49495acb98)),
                          vcreate_f64(UINT64_C(0x3fe7e1902b2a01e5)));
      clear_neon_saturated();
      //  Expect: "result" = 3fe7e1902b2a01e53fe40d24b49a2856
      result = vzip2q_f64(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float64_t got;
         float64_t exp;
         got = vgetq_lane_f64(result, 0);
         exp = 0.6266044165979661;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float64_t got;
         float64_t exp;
         got = vgetq_lane_f64(result, 1);
         exp = 0.7462845652626667;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
   }
}
}
void dotests_3180() {

{
   {
      int8x8_t arg1;
      int8x8_t arg2;
      int8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"uzp1\", fnname = \"vuzp1_s8\", rettype = \"int8x8_t\", argtypes = \"[int8x8_t,int8x8_t]\", vals = [VectorVal [IntegerVal (-1),IntegerVal (-128),IntegerVal 101,IntegerVal (-128),IntegerVal 74,IntegerVal (-128),IntegerVal (-1),IntegerVal (-1)],VectorVal [IntegerVal (-1),IntegerVal (-1),IntegerVal (-128),IntegerVal (-1),IntegerVal (-1),IntegerVal (-62),IntegerVal 0,IntegerVal (-1)]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s8(UINT64_C(0xffff804a806580ff));
      arg2 = vcreate_s8(UINT64_C(0xff00c2ffff80ffff));
      clear_neon_saturated();
      //  Expect: "result" = 00ff80ffff4a65ff
      result = vuzp1_s8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s8(result), 0);
      exp = UINT64_C(0x00ff80ffff4a65ff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_3181() {

{
   {
      int8x8_t arg1;
      int8x8_t arg2;
      int8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"uzp2\", fnname = \"vuzp2_s8\", rettype = \"int8x8_t\", argtypes = \"[int8x8_t,int8x8_t]\", vals = [VectorVal [IntegerVal 0,IntegerVal (-120),IntegerVal 127,IntegerVal 127,IntegerVal 0,IntegerVal 111,IntegerVal (-1),IntegerVal (-111)],VectorVal [IntegerVal (-128),IntegerVal 0,IntegerVal 127,IntegerVal (-1),IntegerVal (-128),IntegerVal 0,IntegerVal 0,IntegerVal 103]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s8(UINT64_C(0x91ff6f007f7f8800));
      arg2 = vcreate_s8(UINT64_C(0x67000080ff7f0080));
      clear_neon_saturated();
      //  Expect: "result" = 6700ff00916f7f88
      result = vuzp2_s8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s8(result), 0);
      exp = UINT64_C(0x6700ff00916f7f88);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_3182() {

{
   {
      int16x4_t arg1;
      int16x4_t arg2;
      int16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"uzp1\", fnname = \"vuzp1_s16\", rettype = \"int16x4_t\", argtypes = \"[int16x4_t,int16x4_t]\", vals = [VectorVal [IntegerVal 32767,IntegerVal 23317,IntegerVal (-32768),IntegerVal (-1)],VectorVal [IntegerVal 32767,IntegerVal (-1),IntegerVal (-32768),IntegerVal 0]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s16(UINT64_C(0xffff80005b157fff));
      arg2 = vcreate_s16(UINT64_C(0x00008000ffff7fff));
      clear_neon_saturated();
      //  Expect: "result" = 80007fff80007fff
      result = vuzp1_s16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s16(result), 0);
      exp = UINT64_C(0x80007fff80007fff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_3183() {

{
   {
      int16x4_t arg1;
      int16x4_t arg2;
      int16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"uzp2\", fnname = \"vuzp2_s16\", rettype = \"int16x4_t\", argtypes = \"[int16x4_t,int16x4_t]\", vals = [VectorVal [IntegerVal (-4462),IntegerVal 32767,IntegerVal (-1),IntegerVal (-32768)],VectorVal [IntegerVal (-1),IntegerVal (-1),IntegerVal 15238,IntegerVal (-1)]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s16(UINT64_C(0x8000ffff7fffee92));
      arg2 = vcreate_s16(UINT64_C(0xffff3b86ffffffff));
      clear_neon_saturated();
      //  Expect: "result" = ffffffff80007fff
      result = vuzp2_s16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s16(result), 0);
      exp = UINT64_C(0xffffffff80007fff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_3184() {

{
   {
      int32x2_t arg1;
      int32x2_t arg2;
      int32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"uzp1\", fnname = \"vuzp1_s32\", rettype = \"int32x2_t\", argtypes = \"[int32x2_t,int32x2_t]\", vals = [VectorVal [IntegerVal (-2147483648),IntegerVal (-2147418113)],VectorVal [IntegerVal (-1239154688),IntegerVal (-2147475902)]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s32(UINT64_C(0x8000ffff80000000));
      arg2 = vcreate_s32(UINT64_C(0x80001e42b6240000));
      clear_neon_saturated();
      //  Expect: "result" = b624000080000000
      result = vuzp1_s32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s32(result), 0);
      exp = UINT64_C(0xb624000080000000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_3185() {

{
   {
      int32x2_t arg1;
      int32x2_t arg2;
      int32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"uzp2\", fnname = \"vuzp2_s32\", rettype = \"int32x2_t\", argtypes = \"[int32x2_t,int32x2_t]\", vals = [VectorVal [IntegerVal (-25128),IntegerVal (-65536)],VectorVal [IntegerVal (-2147450881),IntegerVal 32768]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s32(UINT64_C(0xffff0000ffff9dd8));
      arg2 = vcreate_s32(UINT64_C(0x0000800080007fff));
      clear_neon_saturated();
      //  Expect: "result" = 00008000ffff0000
      result = vuzp2_s32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s32(result), 0);
      exp = UINT64_C(0x00008000ffff0000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_3186() {

{
   {
      uint8x8_t arg1;
      uint8x8_t arg2;
      uint8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"uzp1\", fnname = \"vuzp1_u8\", rettype = \"uint8x8_t\", argtypes = \"[uint8x8_t,uint8x8_t]\", vals = [VectorVal [IntegerVal 0,IntegerVal 128,IntegerVal 128,IntegerVal 255,IntegerVal 255,IntegerVal 0,IntegerVal 108,IntegerVal 128],VectorVal [IntegerVal 109,IntegerVal 128,IntegerVal 0,IntegerVal 0,IntegerVal 0,IntegerVal 127,IntegerVal 0,IntegerVal 0]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u8(UINT64_C(0x806c00ffff808000));
      arg2 = vcreate_u8(UINT64_C(0x00007f000000806d));
      clear_neon_saturated();
      //  Expect: "result" = 0000006d6cff8000
      result = vuzp1_u8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u8(result), 0);
      exp = UINT64_C(0x0000006d6cff8000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_3187() {

{
   {
      uint8x8_t arg1;
      uint8x8_t arg2;
      uint8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"uzp2\", fnname = \"vuzp2_u8\", rettype = \"uint8x8_t\", argtypes = \"[uint8x8_t,uint8x8_t]\", vals = [VectorVal [IntegerVal 255,IntegerVal 127,IntegerVal 127,IntegerVal 127,IntegerVal 128,IntegerVal 0,IntegerVal 255,IntegerVal 255],VectorVal [IntegerVal 0,IntegerVal 255,IntegerVal 111,IntegerVal 128,IntegerVal 127,IntegerVal 127,IntegerVal 127,IntegerVal 127]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u8(UINT64_C(0xffff00807f7f7fff));
      arg2 = vcreate_u8(UINT64_C(0x7f7f7f7f806fff00));
      clear_neon_saturated();
      //  Expect: "result" = 7f7f80ffff007f7f
      result = vuzp2_u8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u8(result), 0);
      exp = UINT64_C(0x7f7f80ffff007f7f);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_3188() {

{
   {
      uint16x4_t arg1;
      uint16x4_t arg2;
      uint16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"uzp1\", fnname = \"vuzp1_u16\", rettype = \"uint16x4_t\", argtypes = \"[uint16x4_t,uint16x4_t]\", vals = [VectorVal [IntegerVal 32768,IntegerVal 15756,IntegerVal 53611,IntegerVal 32767],VectorVal [IntegerVal 32767,IntegerVal 32768,IntegerVal 0,IntegerVal 0]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u16(UINT64_C(0x7fffd16b3d8c8000));
      arg2 = vcreate_u16(UINT64_C(0x0000000080007fff));
      clear_neon_saturated();
      //  Expect: "result" = 00007fffd16b8000
      result = vuzp1_u16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u16(result), 0);
      exp = UINT64_C(0x00007fffd16b8000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_3189() {

{
   {
      uint16x4_t arg1;
      uint16x4_t arg2;
      uint16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"uzp2\", fnname = \"vuzp2_u16\", rettype = \"uint16x4_t\", argtypes = \"[uint16x4_t,uint16x4_t]\", vals = [VectorVal [IntegerVal 0,IntegerVal 65535,IntegerVal 32768,IntegerVal 58544],VectorVal [IntegerVal 5822,IntegerVal 65535,IntegerVal 36422,IntegerVal 0]], start_saturated = True}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u16(UINT64_C(0xe4b08000ffff0000));
      arg2 = vcreate_u16(UINT64_C(0x00008e46ffff16be));
      set_neon_saturated();
      //  Expect: "result" = 0000ffffe4b0ffff
      result = vuzp2_u16(arg1, arg2);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u16(result), 0);
      exp = UINT64_C(0x0000ffffe4b0ffff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_3190() {

{
   {
      uint32x2_t arg1;
      uint32x2_t arg2;
      uint32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"uzp1\", fnname = \"vuzp1_u32\", rettype = \"uint32x2_t\", argtypes = \"[uint32x2_t,uint32x2_t]\", vals = [VectorVal [IntegerVal 2147549183,IntegerVal 65535],VectorVal [IntegerVal 692862444,IntegerVal 3080814591]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u32(UINT64_C(0x0000ffff8000ffff));
      arg2 = vcreate_u32(UINT64_C(0xb7a17fff294c3dec));
      clear_neon_saturated();
      //  Expect: "result" = 294c3dec8000ffff
      result = vuzp1_u32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u32(result), 0);
      exp = UINT64_C(0x294c3dec8000ffff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_3191() {

{
   {
      uint32x2_t arg1;
      uint32x2_t arg2;
      uint32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"uzp2\", fnname = \"vuzp2_u32\", rettype = \"uint32x2_t\", argtypes = \"[uint32x2_t,uint32x2_t]\", vals = [VectorVal [IntegerVal 2147516416,IntegerVal 4294934528],VectorVal [IntegerVal 3201757159,IntegerVal 2147549183]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u32(UINT64_C(0xffff800080008000));
      arg2 = vcreate_u32(UINT64_C(0x8000ffffbed6efe7));
      clear_neon_saturated();
      //  Expect: "result" = 8000ffffffff8000
      result = vuzp2_u32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u32(result), 0);
      exp = UINT64_C(0x8000ffffffff8000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_3192() {

{
   {
      poly8x8_t arg1;
      poly8x8_t arg2;
      poly8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"uzp1\", fnname = \"vuzp1_p8\", rettype = \"poly8x8_t\", argtypes = \"[poly8x8_t,poly8x8_t]\", vals = [VectorVal [PolyVal [0,0,0,1,0,0,0,0],PolyVal [1,0,0,0,1,1,1,1],PolyVal [1,0,0,0,1,0,0,0],PolyVal [1,1,0,0,1,1,0,0],PolyVal [0,1,1,0,0,1,0,0],PolyVal [0,0,0,0,1,0,0,0],PolyVal [0,1,0,0,1,1,0,1],PolyVal [1,1,0,0,1,0,1,0]],VectorVal [PolyVal [1,1,1,0,0,1,1,0],PolyVal [0,1,0,0,1,0,1,0],PolyVal [1,1,0,1,0,1,0,1],PolyVal [0,1,0,1,0,1,1,0],PolyVal [0,1,1,1,0,1,1,1],PolyVal [1,0,0,1,1,0,1,0],PolyVal [1,0,0,0,1,1,1,1],PolyVal [1,1,0,1,0,0,0,1]]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_p8(UINT64_C(0x53b210263311f108));
      arg2 = vcreate_p8(UINT64_C(0x8bf159ee6aab5267));
      clear_neon_saturated();
      //  Expect: "result" = f1eeab67b2261108
      result = vuzp1_p8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_p8(result), 0);
      exp = UINT64_C(0xf1eeab67b2261108);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_3193() {

{
   {
      poly8x8_t arg1;
      poly8x8_t arg2;
      poly8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"uzp2\", fnname = \"vuzp2_p8\", rettype = \"poly8x8_t\", argtypes = \"[poly8x8_t,poly8x8_t]\", vals = [VectorVal [PolyVal [0,1,1,0,1,0,1,0],PolyVal [1,1,1,0,1,1,0,0],PolyVal [0,1,1,1,1,0,1,0],PolyVal [1,0,1,0,0,0,0,1],PolyVal [0,0,1,0,0,0,0,1],PolyVal [0,0,1,0,0,1,1,1],PolyVal [0,0,1,1,1,0,0,1],PolyVal [0,1,0,1,1,1,1,0]],VectorVal [PolyVal [0,1,1,1,0,0,0,0],PolyVal [1,0,0,1,0,1,1,0],PolyVal [1,0,1,0,0,0,0,1],PolyVal [0,0,0,1,1,1,1,0],PolyVal [1,1,0,1,0,0,0,1],PolyVal [0,1,1,1,0,1,0,0],PolyVal [1,0,1,1,0,0,0,1],PolyVal [0,1,0,1,0,1,0,1]]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_p8(UINT64_C(0x7a9ce484855e3756));
      arg2 = vcreate_p8(UINT64_C(0xaa8d2e8b7885690e));
      clear_neon_saturated();
      //  Expect: "result" = aa2e78697ae48537
      result = vuzp2_p8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_p8(result), 0);
      exp = UINT64_C(0xaa2e78697ae48537);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_3194() {

{
   {
      poly16x4_t arg1;
      poly16x4_t arg2;
      poly16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"uzp1\", fnname = \"vuzp1_p16\", rettype = \"poly16x4_t\", argtypes = \"[poly16x4_t,poly16x4_t]\", vals = [VectorVal [PolyVal [0,0,1,0,0,1,1,0,1,0,0,1,0,0,1,1],PolyVal [0,0,1,0,0,0,0,0,1,1,0,1,1,1,0,0],PolyVal [1,1,1,1,0,0,1,0,1,1,1,0,0,0,1,1],PolyVal [0,1,1,0,1,0,1,1,0,1,1,1,1,0,1,0]],VectorVal [PolyVal [0,1,0,0,1,0,1,1,1,1,0,0,1,1,0,0],PolyVal [0,1,1,0,0,1,0,1,0,0,0,1,1,0,1,0],PolyVal [1,1,0,1,0,1,0,0,1,0,1,0,0,1,1,1],PolyVal [1,1,1,1,1,1,0,0,0,0,0,0,0,1,1,1]]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_p16(UINT64_C(0x5ed6c74f3b04c964));
      arg2 = vcreate_p16(UINT64_C(0xe03fe52b58a633d2));
      clear_neon_saturated();
      //  Expect: "result" = e52b33d2c74fc964
      result = vuzp1_p16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_p16(result), 0);
      exp = UINT64_C(0xe52b33d2c74fc964);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_3195() {

{
   {
      poly16x4_t arg1;
      poly16x4_t arg2;
      poly16x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"uzp2\", fnname = \"vuzp2_p16\", rettype = \"poly16x4_t\", argtypes = \"[poly16x4_t,poly16x4_t]\", vals = [VectorVal [PolyVal [0,1,0,1,0,0,1,0,1,0,0,0,0,0,1,0],PolyVal [0,0,1,0,1,0,1,0,0,0,1,1,1,1,1,1],PolyVal [1,0,0,1,1,0,1,1,1,1,1,1,1,1,0,0],PolyVal [0,0,1,0,1,1,0,0,0,1,1,0,0,0,1,0]],VectorVal [PolyVal [1,1,1,0,1,0,0,1,0,0,0,1,0,1,1,0],PolyVal [1,1,1,1,0,1,0,1,1,1,1,1,0,1,1,0],PolyVal [0,1,0,0,0,0,1,1,0,1,0,0,1,0,0,1],PolyVal [0,0,1,0,1,1,0,1,1,0,1,0,0,0,1,1]]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_p16(UINT64_C(0x46343fd9fc54414a));
      arg2 = vcreate_p16(UINT64_C(0xc5b492c26faf6897));
      clear_neon_saturated();
      //  Expect: "result" = c5b46faf4634fc54
      result = vuzp2_p16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_p16(result), 0);
      exp = UINT64_C(0xc5b46faf4634fc54);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_3196() {

{
   {
      float32x2_t arg1;
      float32x2_t arg2;
      float32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"uzp1\", fnname = \"vuzp1_f32\", rettype = \"float32x2_t\", argtypes = \"[float32x2_t,float32x2_t]\", vals = [VectorVal [FloatVal 0.8417661190032959,FloatVal 0.5361537933349609],VectorVal [FloatVal 0.6134002208709717,FloatVal 0.4156839847564697]], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_f32(UINT64_C(0x3f0941603f577dfc));
      arg2 = vcreate_f32(UINT64_C(0x3ed4d4883f1d07cc));
      clear_neon_saturated();
      //  Expect: "result" = 3f1d07cc3f577dfc
      result = vuzp1_f32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result, 0);
         exp = ((float32_t) 0.8417661190032959);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result, 1);
         exp = ((float32_t) 0.6134002208709717);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
   }
}
}
void dotests_3197() {

{
   {
      float32x2_t arg1;
      float32x2_t arg2;
      float32x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"uzp2\", fnname = \"vuzp2_f32\", rettype = \"float32x2_t\", argtypes = \"[float32x2_t,float32x2_t]\", vals = [VectorVal [FloatVal 0.3465456962585449,FloatVal 0.42561066150665283],VectorVal [FloatVal 0.46444618701934814,FloatVal 0.18595564365386963]], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_f32(UINT64_C(0x3ed9e9a43eb16e70));
      arg2 = vcreate_f32(UINT64_C(0x3e3e6b283eedcbe4));
      clear_neon_saturated();
      //  Expect: "result" = 3e3e6b283ed9e9a4
      result = vuzp2_f32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result, 0);
         exp = ((float32_t) 0.42561066150665283);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result, 1);
         exp = ((float32_t) 0.18595564365386963);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
   }
}
}
void dotests_3198() {

{
   {
      int8x16_t arg1;
      int8x16_t arg2;
      int8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"uzp1\", fnname = \"vuzp1q_s8\", rettype = \"int8x16_t\", argtypes = \"[int8x16_t,int8x16_t]\", vals = [VectorVal [IntegerVal (-128),IntegerVal 0,IntegerVal (-128),IntegerVal 0,IntegerVal 127,IntegerVal 0,IntegerVal (-37),IntegerVal 0,IntegerVal 50,IntegerVal (-128),IntegerVal (-1),IntegerVal (-96),IntegerVal 127,IntegerVal (-128),IntegerVal (-1),IntegerVal 83],VectorVal [IntegerVal 127,IntegerVal 127,IntegerVal (-128),IntegerVal 127,IntegerVal (-128),IntegerVal 127,IntegerVal 127,IntegerVal (-128),IntegerVal (-128),IntegerVal 127,IntegerVal 0,IntegerVal (-1),IntegerVal 127,IntegerVal 0,IntegerVal 0,IntegerVal 0]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s8(vcreate_s8(UINT64_C(0x00db007f00800080)),
                         vcreate_s8(UINT64_C(0x53ff807fa0ff8032)));
      arg2 = vcombine_s8(vcreate_s8(UINT64_C(0x807f7f807f807f7f)),
                         vcreate_s8(UINT64_C(0x0000007fff007f80)));
      clear_neon_saturated();
      //  Expect: "result" = 007f00807f80807fff7fff32db7f8080
      result = vuzp1q_s8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result), 0);
         exp = UINT64_C(0xff7fff32db7f8080);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result), 1);
         exp = UINT64_C(0x007f00807f80807f);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_3199() {

{
   {
      int8x16_t arg1;
      int8x16_t arg2;
      int8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"uzp2\", fnname = \"vuzp2q_s8\", rettype = \"int8x16_t\", argtypes = \"[int8x16_t,int8x16_t]\", vals = [VectorVal [IntegerVal (-1),IntegerVal (-1),IntegerVal 127,IntegerVal (-1),IntegerVal (-128),IntegerVal 0,IntegerVal 127,IntegerVal 0,IntegerVal 28,IntegerVal 0,IntegerVal (-82),IntegerVal 120,IntegerVal (-59),IntegerVal 0,IntegerVal 0,IntegerVal 127],VectorVal [IntegerVal (-1),IntegerVal 127,IntegerVal (-24),IntegerVal 0,IntegerVal 127,IntegerVal 0,IntegerVal 0,IntegerVal (-128),IntegerVal (-128),IntegerVal (-128),IntegerVal (-128),IntegerVal 27,IntegerVal 127,IntegerVal (-128),IntegerVal 127,IntegerVal 0]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s8(vcreate_s8(UINT64_C(0x007f0080ff7fffff)),
                         vcreate_s8(UINT64_C(0x7f0000c578ae001c)));
      arg2 = vcombine_s8(vcreate_s8(UINT64_C(0x8000007f00e87fff)),
                         vcreate_s8(UINT64_C(0x007f807f1b808080)));
      clear_neon_saturated();
      //  Expect: "result" = 00801b808000007f7f0078000000ffff
      result = vuzp2q_s8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result), 0);
         exp = UINT64_C(0x7f0078000000ffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result), 1);
         exp = UINT64_C(0x00801b808000007f);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_3200() {

{
   {
      int16x8_t arg1;
      int16x8_t arg2;
      int16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"uzp1\", fnname = \"vuzp1q_s16\", rettype = \"int16x8_t\", argtypes = \"[int16x8_t,int16x8_t]\", vals = [VectorVal [IntegerVal (-8476),IntegerVal 10430,IntegerVal (-32768),IntegerVal (-9278),IntegerVal (-1),IntegerVal 0,IntegerVal 0,IntegerVal (-18486)],VectorVal [IntegerVal 0,IntegerVal 0,IntegerVal (-32768),IntegerVal 32767,IntegerVal (-23584),IntegerVal (-1),IntegerVal 0,IntegerVal (-1)]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s16(vcreate_s16(UINT64_C(0xdbc2800028bedee4)),
                          vcreate_s16(UINT64_C(0xb7ca00000000ffff)));
      arg2 = vcombine_s16(vcreate_s16(UINT64_C(0x7fff800000000000)),
                          vcreate_s16(UINT64_C(0xffff0000ffffa3e0)));
      clear_neon_saturated();
      //  Expect: "result" = 0000a3e0800000000000ffff8000dee4
      result = vuzp1q_s16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 0);
         exp = UINT64_C(0x0000ffff8000dee4);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 1);
         exp = UINT64_C(0x0000a3e080000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_3201() {

{
   {
      int16x8_t arg1;
      int16x8_t arg2;
      int16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"uzp2\", fnname = \"vuzp2q_s16\", rettype = \"int16x8_t\", argtypes = \"[int16x8_t,int16x8_t]\", vals = [VectorVal [IntegerVal 32767,IntegerVal 32767,IntegerVal (-32768),IntegerVal 0,IntegerVal (-1),IntegerVal 0,IntegerVal 32767,IntegerVal (-32123)],VectorVal [IntegerVal 0,IntegerVal 32767,IntegerVal (-14107),IntegerVal 0,IntegerVal (-1),IntegerVal 0,IntegerVal (-27934),IntegerVal 0]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s16(vcreate_s16(UINT64_C(0x000080007fff7fff)),
                          vcreate_s16(UINT64_C(0x82857fff0000ffff)));
      arg2 = vcombine_s16(vcreate_s16(UINT64_C(0x0000c8e57fff0000)),
                          vcreate_s16(UINT64_C(0x000092e20000ffff)));
      clear_neon_saturated();
      //  Expect: "result" = 0000000000007fff8285000000007fff
      result = vuzp2q_s16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 0);
         exp = UINT64_C(0x8285000000007fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result), 1);
         exp = UINT64_C(0x0000000000007fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_3202() {

{
   {
      int32x4_t arg1;
      int32x4_t arg2;
      int32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"uzp1\", fnname = \"vuzp1q_s32\", rettype = \"int32x4_t\", argtypes = \"[int32x4_t,int32x4_t]\", vals = [VectorVal [IntegerVal 418185215,IntegerVal 32768,IntegerVal 2147450879,IntegerVal 2147440146],VectorVal [IntegerVal (-32768),IntegerVal (-1433468929),IntegerVal 1857978368,IntegerVal 2147450879]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s32(vcreate_s32(UINT64_C(0x0000800018ecffff)),
                          vcreate_s32(UINT64_C(0x7fff56127fff7fff)));
      arg2 = vcombine_s32(vcreate_s32(UINT64_C(0xaa8effffffff8000)),
                          vcreate_s32(UINT64_C(0x7fff7fff6ebe8000)));
      clear_neon_saturated();
      //  Expect: "result" = 6ebe8000ffff80007fff7fff18ecffff
      result = vuzp1q_s32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 0);
         exp = UINT64_C(0x7fff7fff18ecffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 1);
         exp = UINT64_C(0x6ebe8000ffff8000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_3203() {

{
   {
      int32x4_t arg1;
      int32x4_t arg2;
      int32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"uzp2\", fnname = \"vuzp2q_s32\", rettype = \"int32x4_t\", argtypes = \"[int32x4_t,int32x4_t]\", vals = [VectorVal [IntegerVal 2147450879,IntegerVal 0,IntegerVal 65535,IntegerVal 81952767],VectorVal [IntegerVal (-32769),IntegerVal (-2147450881),IntegerVal (-56358),IntegerVal (-459112448)]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s32(vcreate_s32(UINT64_C(0x000000007fff7fff)),
                          vcreate_s32(UINT64_C(0x04e27fff0000ffff)));
      arg2 = vcombine_s32(vcreate_s32(UINT64_C(0x80007fffffff7fff)),
                          vcreate_s32(UINT64_C(0xe4a28000ffff23da)));
      clear_neon_saturated();
      //  Expect: "result" = e4a2800080007fff04e27fff00000000
      result = vuzp2q_s32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 0);
         exp = UINT64_C(0x04e27fff00000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result), 1);
         exp = UINT64_C(0xe4a2800080007fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_3204() {

{
   {
      int64x2_t arg1;
      int64x2_t arg2;
      int64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"uzp1\", fnname = \"vuzp1q_s64\", rettype = \"int64x2_t\", argtypes = \"[int64x2_t,int64x2_t]\", vals = [VectorVal [IntegerVal 2608428607030198271,IntegerVal (-7982911812343496704)],VectorVal [IntegerVal (-9223231299366486016),IntegerVal 9223191583803834367]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s64(vcreate_s64(UINT64_C(0x2432ffff80007fff)),
                          vcreate_s64(UINT64_C(0x913700007fff0000)));
      arg2 = vcombine_s64(vcreate_s64(UINT64_C(0x80007fffffff0000)),
                          vcreate_s64(UINT64_C(0x7fff5be0ffffffff)));
      clear_neon_saturated();
      //  Expect: "result" = 80007fffffff00002432ffff80007fff
      result = vuzp1q_s64(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 0);
         exp = UINT64_C(0x2432ffff80007fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 1);
         exp = UINT64_C(0x80007fffffff0000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_3205() {

{
   {
      int64x2_t arg1;
      int64x2_t arg2;
      int64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"uzp2\", fnname = \"vuzp2q_s64\", rettype = \"int64x2_t\", argtypes = \"[int64x2_t,int64x2_t]\", vals = [VectorVal [IntegerVal (-9223090562170945537),IntegerVal 92103952261343],VectorVal [IntegerVal (-544372608215547905),IntegerVal (-9223231299366420481)]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s64(vcreate_s64(UINT64_C(0x8000ffffee8affff)),
                          vcreate_s64(UINT64_C(0x000053c49f5b60df)));
      arg2 = vcombine_s64(vcreate_s64(UINT64_C(0xf871ffff3ddbffff)),
                          vcreate_s64(UINT64_C(0x80007fffffffffff)));
      clear_neon_saturated();
      //  Expect: "result" = 80007fffffffffff000053c49f5b60df
      result = vuzp2q_s64(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 0);
         exp = UINT64_C(0x000053c49f5b60df);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s64(result), 1);
         exp = UINT64_C(0x80007fffffffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_3206() {

{
   {
      uint8x16_t arg1;
      uint8x16_t arg2;
      uint8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"uzp1\", fnname = \"vuzp1q_u8\", rettype = \"uint8x16_t\", argtypes = \"[uint8x16_t,uint8x16_t]\", vals = [VectorVal [IntegerVal 0,IntegerVal 36,IntegerVal 255,IntegerVal 127,IntegerVal 0,IntegerVal 0,IntegerVal 0,IntegerVal 255,IntegerVal 0,IntegerVal 127,IntegerVal 127,IntegerVal 255,IntegerVal 0,IntegerVal 128,IntegerVal 0,IntegerVal 0],VectorVal [IntegerVal 255,IntegerVal 255,IntegerVal 153,IntegerVal 155,IntegerVal 127,IntegerVal 255,IntegerVal 255,IntegerVal 127,IntegerVal 255,IntegerVal 127,IntegerVal 255,IntegerVal 176,IntegerVal 128,IntegerVal 0,IntegerVal 128,IntegerVal 242]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u8(vcreate_u8(UINT64_C(0xff0000007fff2400)),
                         vcreate_u8(UINT64_C(0x00008000ff7f7f00)));
      arg2 = vcombine_u8(vcreate_u8(UINT64_C(0x7fffff7f9b99ffff)),
                         vcreate_u8(UINT64_C(0xf2800080b0ff7fff)));
      clear_neon_saturated();
      //  Expect: "result" = 8080ffffff7f99ff00007f000000ff00
      result = vuzp1q_u8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 0);
         exp = UINT64_C(0x00007f000000ff00);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 1);
         exp = UINT64_C(0x8080ffffff7f99ff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_3207() {

{
   {
      uint8x16_t arg1;
      uint8x16_t arg2;
      uint8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"uzp2\", fnname = \"vuzp2q_u8\", rettype = \"uint8x16_t\", argtypes = \"[uint8x16_t,uint8x16_t]\", vals = [VectorVal [IntegerVal 0,IntegerVal 127,IntegerVal 127,IntegerVal 255,IntegerVal 127,IntegerVal 255,IntegerVal 128,IntegerVal 128,IntegerVal 0,IntegerVal 128,IntegerVal 128,IntegerVal 0,IntegerVal 128,IntegerVal 128,IntegerVal 255,IntegerVal 127],VectorVal [IntegerVal 0,IntegerVal 128,IntegerVal 127,IntegerVal 92,IntegerVal 0,IntegerVal 128,IntegerVal 0,IntegerVal 255,IntegerVal 0,IntegerVal 128,IntegerVal 249,IntegerVal 196,IntegerVal 0,IntegerVal 127,IntegerVal 128,IntegerVal 127]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u8(vcreate_u8(UINT64_C(0x8080ff7fff7f7f00)),
                         vcreate_u8(UINT64_C(0x7fff808000808000)));
      arg2 = vcombine_u8(vcreate_u8(UINT64_C(0xff0080005c7f8000)),
                         vcreate_u8(UINT64_C(0x7f807f00c4f98000)));
      clear_neon_saturated();
      //  Expect: "result" = 7f7fc480ff805c807f80008080ffff7f
      result = vuzp2q_u8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 0);
         exp = UINT64_C(0x7f80008080ffff7f);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result), 1);
         exp = UINT64_C(0x7f7fc480ff805c80);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_3208() {

{
   {
      uint16x8_t arg1;
      uint16x8_t arg2;
      uint16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"uzp1\", fnname = \"vuzp1q_u16\", rettype = \"uint16x8_t\", argtypes = \"[uint16x8_t,uint16x8_t]\", vals = [VectorVal [IntegerVal 65535,IntegerVal 65535,IntegerVal 32767,IntegerVal 32768,IntegerVal 11893,IntegerVal 32768,IntegerVal 0,IntegerVal 32768],VectorVal [IntegerVal 32768,IntegerVal 9372,IntegerVal 0,IntegerVal 32768,IntegerVal 65535,IntegerVal 35502,IntegerVal 26169,IntegerVal 23528]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u16(vcreate_u16(UINT64_C(0x80007fffffffffff)),
                          vcreate_u16(UINT64_C(0x8000000080002e75)));
      arg2 = vcombine_u16(vcreate_u16(UINT64_C(0x80000000249c8000)),
                          vcreate_u16(UINT64_C(0x5be866398aaeffff)));
      clear_neon_saturated();
      //  Expect: "result" = 6639ffff0000800000002e757fffffff
      result = vuzp1q_u16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 0);
         exp = UINT64_C(0x00002e757fffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 1);
         exp = UINT64_C(0x6639ffff00008000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_3209() {

{
   {
      uint16x8_t arg1;
      uint16x8_t arg2;
      uint16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"uzp2\", fnname = \"vuzp2q_u16\", rettype = \"uint16x8_t\", argtypes = \"[uint16x8_t,uint16x8_t]\", vals = [VectorVal [IntegerVal 65535,IntegerVal 0,IntegerVal 37693,IntegerVal 32767,IntegerVal 65535,IntegerVal 32767,IntegerVal 0,IntegerVal 16144],VectorVal [IntegerVal 65535,IntegerVal 32768,IntegerVal 7426,IntegerVal 65535,IntegerVal 29686,IntegerVal 57390,IntegerVal 32767,IntegerVal 11585]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u16(vcreate_u16(UINT64_C(0x7fff933d0000ffff)),
                          vcreate_u16(UINT64_C(0x3f1000007fffffff)));
      arg2 = vcombine_u16(vcreate_u16(UINT64_C(0xffff1d028000ffff)),
                          vcreate_u16(UINT64_C(0x2d417fffe02e73f6)));
      clear_neon_saturated();
      //  Expect: "result" = 2d41e02effff80003f107fff7fff0000
      result = vuzp2q_u16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 0);
         exp = UINT64_C(0x3f107fff7fff0000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result), 1);
         exp = UINT64_C(0x2d41e02effff8000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_3210() {

{
   {
      uint32x4_t arg1;
      uint32x4_t arg2;
      uint32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"uzp1\", fnname = \"vuzp1q_u32\", rettype = \"uint32x4_t\", argtypes = \"[uint32x4_t,uint32x4_t]\", vals = [VectorVal [IntegerVal 0,IntegerVal 2147450879,IntegerVal 2147483648,IntegerVal 4270227456],VectorVal [IntegerVal 2867199999,IntegerVal 55878,IntegerVal 4294967295,IntegerVal 409632624]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u32(vcreate_u32(UINT64_C(0x7fff7fff00000000)),
                          vcreate_u32(UINT64_C(0xfe86800080000000)));
      arg2 = vcombine_u32(vcreate_u32(UINT64_C(0x0000da46aae5ffff)),
                          vcreate_u32(UINT64_C(0x186a7f70ffffffff)));
      clear_neon_saturated();
      //  Expect: "result" = ffffffffaae5ffff8000000000000000
      result = vuzp1q_u32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 0);
         exp = UINT64_C(0x8000000000000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 1);
         exp = UINT64_C(0xffffffffaae5ffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_3211() {

{
   {
      uint32x4_t arg1;
      uint32x4_t arg2;
      uint32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"uzp2\", fnname = \"vuzp2q_u32\", rettype = \"uint32x4_t\", argtypes = \"[uint32x4_t,uint32x4_t]\", vals = [VectorVal [IntegerVal 4294901760,IntegerVal 2147450879,IntegerVal 2147516415,IntegerVal 2097054504],VectorVal [IntegerVal 2147418112,IntegerVal 2147450880,IntegerVal 4294967295,IntegerVal 2147450879]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u32(vcreate_u32(UINT64_C(0x7fff7fffffff0000)),
                          vcreate_u32(UINT64_C(0x7cfe832880007fff)));
      arg2 = vcombine_u32(vcreate_u32(UINT64_C(0x7fff80007fff0000)),
                          vcreate_u32(UINT64_C(0x7fff7fffffffffff)));
      clear_neon_saturated();
      //  Expect: "result" = 7fff7fff7fff80007cfe83287fff7fff
      result = vuzp2q_u32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 0);
         exp = UINT64_C(0x7cfe83287fff7fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result), 1);
         exp = UINT64_C(0x7fff7fff7fff8000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_3212() {

{
   {
      uint64x2_t arg1;
      uint64x2_t arg2;
      uint64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"uzp1\", fnname = \"vuzp1q_u64\", rettype = \"uint64x2_t\", argtypes = \"[uint64x2_t,uint64x2_t]\", vals = [VectorVal [IntegerVal 4294934527,IntegerVal 98197984792640],VectorVal [IntegerVal 32767,IntegerVal 9223372036854775807]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u64(vcreate_u64(UINT64_C(0x00000000ffff7fff)),
                          vcreate_u64(UINT64_C(0x0000594f80005040)));
      arg2 = vcombine_u64(vcreate_u64(UINT64_C(0x0000000000007fff)),
                          vcreate_u64(UINT64_C(0x7fffffffffffffff)));
      clear_neon_saturated();
      //  Expect: "result" = 0000000000007fff00000000ffff7fff
      result = vuzp1q_u64(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 0);
         exp = UINT64_C(0x00000000ffff7fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 1);
         exp = UINT64_C(0x0000000000007fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_3213() {

{
   {
      uint64x2_t arg1;
      uint64x2_t arg2;
      uint64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"uzp2\", fnname = \"vuzp2q_u64\", rettype = \"uint64x2_t\", argtypes = \"[uint64x2_t,uint64x2_t]\", vals = [VectorVal [IntegerVal 13667788883197165567,IntegerVal 18322472869557172134],VectorVal [IntegerVal 18446744071562067968,IntegerVal 140733732257791]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u64(vcreate_u64(UINT64_C(0xbdadbd92ffffffff)),
                          vcreate_u64(UINT64_C(0xfe467fff8caff7a6)));
      arg2 = vcombine_u64(vcreate_u64(UINT64_C(0xffffffff80000000)),
                          vcreate_u64(UINT64_C(0x00007fff201e7fff)));
      clear_neon_saturated();
      //  Expect: "result" = 00007fff201e7ffffe467fff8caff7a6
      result = vuzp2q_u64(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 0);
         exp = UINT64_C(0xfe467fff8caff7a6);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(result, 1);
         exp = UINT64_C(0x00007fff201e7fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_3214() {

{
   {
      poly8x16_t arg1;
      poly8x16_t arg2;
      poly8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"uzp1\", fnname = \"vuzp1q_p8\", rettype = \"poly8x16_t\", argtypes = \"[poly8x16_t,poly8x16_t]\", vals = [VectorVal [PolyVal [1,0,1,0,1,0,0,0],PolyVal [0,0,1,1,0,1,0,1],PolyVal [0,1,0,0,1,0,0,1],PolyVal [0,0,1,0,0,1,0,1],PolyVal [0,1,1,1,0,0,1,1],PolyVal [0,1,1,0,0,0,1,1],PolyVal [0,1,0,1,1,0,0,0],PolyVal [0,1,1,0,1,0,0,1],PolyVal [0,1,1,1,0,1,0,1],PolyVal [1,0,1,1,0,0,0,1],PolyVal [0,1,0,1,1,0,0,0],PolyVal [1,1,0,0,0,1,0,1],PolyVal [1,1,1,1,1,1,0,0],PolyVal [1,1,1,1,1,1,0,1],PolyVal [0,1,0,1,0,1,1,1],PolyVal [0,0,0,0,1,1,0,1]],VectorVal [PolyVal [0,0,0,1,1,1,0,0],PolyVal [0,0,1,0,0,1,1,1],PolyVal [1,1,1,0,1,1,0,0],PolyVal [0,0,0,0,1,0,1,0],PolyVal [1,0,1,0,1,1,0,1],PolyVal [1,0,1,0,1,1,0,0],PolyVal [1,0,1,0,1,0,0,0],PolyVal [1,1,0,1,0,0,0,0],PolyVal [0,0,0,0,0,0,1,0],PolyVal [1,0,0,0,1,0,0,0],PolyVal [1,0,1,0,1,0,1,0],PolyVal [1,1,1,1,0,0,0,1],PolyVal [1,1,1,0,0,1,0,1],PolyVal [0,0,0,0,0,1,1,0],PolyVal [1,1,1,0,1,0,0,1],PolyVal [0,1,0,0,0,1,1,0]]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_p8(vcreate_p8(UINT64_C(0x961ac6cea492ac15)),
                         vcreate_p8(UINT64_C(0xb0eabf3fa31a8dae)));
      arg2 = vcombine_p8(vcreate_p8(UINT64_C(0x0b1535b55037e438)),
                         vcreate_p8(UINT64_C(0x629760a78f551140)));
      clear_neon_saturated();
      //  Expect: "result" = 97a7554015b53738ea3f1aae1ace9215
      result = vuzp1q_p8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p8(result), 0);
         exp = UINT64_C(0xea3f1aae1ace9215);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p8(result), 1);
         exp = UINT64_C(0x97a7554015b53738);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_3215() {

{
   {
      poly8x16_t arg1;
      poly8x16_t arg2;
      poly8x16_t result;
      char* str1 = "ReproInfo2 {semantics = \"uzp2\", fnname = \"vuzp2q_p8\", rettype = \"poly8x16_t\", argtypes = \"[poly8x16_t,poly8x16_t]\", vals = [VectorVal [PolyVal [1,1,0,1,0,0,1,0],PolyVal [0,0,1,0,0,1,0,1],PolyVal [0,0,1,1,1,0,0,0],PolyVal [0,0,0,1,0,1,0,0],PolyVal [1,1,0,0,0,0,1,0],PolyVal [1,1,0,1,1,0,1,0],PolyVal [1,0,0,1,0,1,1,1],PolyVal [0,1,0,0,1,0,1,0],PolyVal [0,1,0,1,1,1,1,1],PolyVal [0,0,0,0,0,0,1,0],PolyVal [1,0,0,0,1,1,0,1],PolyVal [0,1,0,0,0,0,0,0],PolyVal [1,0,1,1,1,1,0,1],PolyVal [0,1,1,0,0,0,1,0],PolyVal [1,1,0,1,0,0,1,0],PolyVal [0,0,1,0,0,1,0,1]],VectorVal [PolyVal [0,1,0,0,1,1,1,1],PolyVal [1,1,0,0,1,1,0,0],PolyVal [1,0,0,1,0,0,1,0],PolyVal [1,0,1,1,1,1,0,1],PolyVal [0,1,1,0,1,0,0,1],PolyVal [0,1,0,0,1,1,0,0],PolyVal [1,1,1,1,0,1,0,0],PolyVal [0,0,0,0,0,0,1,1],PolyVal [1,1,0,0,1,1,0,1],PolyVal [1,0,1,1,1,0,1,1],PolyVal [1,1,0,0,1,1,0,1],PolyVal [1,0,0,1,1,1,0,0],PolyVal [1,0,1,1,1,0,1,0],PolyVal [1,1,0,0,1,1,1,1],PolyVal [0,1,1,1,1,0,1,1],PolyVal [0,1,1,0,1,0,0,0]]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_p8(vcreate_p8(UINT64_C(0x52e95b43281ca44b)),
                         vcreate_p8(UINT64_C(0xa44b46bd02b140fa)));
      arg2 = vcombine_p8(vcreate_p8(UINT64_C(0xc02f3296bd4933f2)),
                         vcreate_p8(UINT64_C(0x16def35d39b3ddb3)));
      clear_neon_saturated();
      //  Expect: "result" = 16f339ddc032bd33a4460240525b28a4
      result = vuzp2q_p8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p8(result), 0);
         exp = UINT64_C(0xa4460240525b28a4);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p8(result), 1);
         exp = UINT64_C(0x16f339ddc032bd33);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_3216() {

{
   {
      poly16x8_t arg1;
      poly16x8_t arg2;
      poly16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"uzp1\", fnname = \"vuzp1q_p16\", rettype = \"poly16x8_t\", argtypes = \"[poly16x8_t,poly16x8_t]\", vals = [VectorVal [PolyVal [1,1,0,1,0,0,1,1,0,0,1,1,0,0,1,0],PolyVal [1,0,0,0,1,1,1,0,1,0,1,1,0,0,0,0],PolyVal [1,1,1,0,1,0,1,1,0,0,1,0,0,1,1,0],PolyVal [0,0,1,1,1,1,0,1,0,0,1,1,0,1,1,0],PolyVal [1,0,1,1,1,0,0,1,0,1,0,1,0,1,1,0],PolyVal [0,1,0,0,0,0,0,1,1,0,0,0,0,0,1,1],PolyVal [1,0,0,1,0,1,0,1,0,0,1,0,0,1,1,1],PolyVal [1,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0]],VectorVal [PolyVal [0,1,1,1,0,0,0,0,1,1,0,0,0,0,0,1],PolyVal [0,1,0,1,0,1,1,0,1,0,0,0,1,0,0,1],PolyVal [1,0,1,0,1,1,1,1,0,1,1,1,0,0,1,0],PolyVal [1,0,1,0,0,1,1,0,0,0,0,1,1,0,0,1],PolyVal [0,1,0,0,1,1,1,0,0,0,1,1,1,1,1,1],PolyVal [0,0,0,0,1,1,1,0,0,0,0,1,1,0,0,0],PolyVal [0,0,1,0,0,1,1,0,0,0,0,0,0,1,0,1],PolyVal [0,1,1,0,1,1,1,0,1,0,0,0,0,1,0,0]]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_p16(vcreate_p16(UINT64_C(0x6cbc64d70d714ccb)),
                          vcreate_p16(UINT64_C(0x2043e4a9c1826a9d)));
      arg2 = vcombine_p16(vcreate_p16(UINT64_C(0x98654ef5916a830e)),
                          vcreate_p16(UINT64_C(0x2176a0641870fc72)));
      clear_neon_saturated();
      //  Expect: "result" = a064fc724ef5830ee4a96a9d64d74ccb
      result = vuzp1q_p16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p16(result), 0);
         exp = UINT64_C(0xe4a96a9d64d74ccb);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p16(result), 1);
         exp = UINT64_C(0xa064fc724ef5830e);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_3217() {

{
   {
      poly16x8_t arg1;
      poly16x8_t arg2;
      poly16x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"uzp2\", fnname = \"vuzp2q_p16\", rettype = \"poly16x8_t\", argtypes = \"[poly16x8_t,poly16x8_t]\", vals = [VectorVal [PolyVal [0,1,1,0,0,1,0,1,0,0,0,0,1,1,0,1],PolyVal [1,0,1,1,1,0,1,1,0,0,0,1,0,0,0,1],PolyVal [0,0,0,0,1,1,1,0,0,0,1,1,0,0,0,1],PolyVal [1,1,1,0,1,0,1,0,1,0,0,1,0,0,0,0],PolyVal [1,1,0,1,0,0,1,1,0,0,1,1,0,1,0,1],PolyVal [0,1,0,1,0,1,0,1,1,0,0,1,0,0,1,0],PolyVal [1,1,1,0,1,0,1,0,1,0,1,1,0,0,1,0],PolyVal [1,1,1,1,1,1,0,0,0,1,0,0,0,1,1,1]],VectorVal [PolyVal [1,1,1,0,1,0,0,1,1,1,1,0,0,0,1,0],PolyVal [0,1,0,1,0,0,1,1,0,0,0,1,0,0,0,1],PolyVal [0,0,1,0,1,0,0,0,0,1,0,1,0,0,1,0],PolyVal [0,0,1,0,1,0,0,0,0,1,0,1,0,1,1,0],PolyVal [1,1,1,0,1,0,1,0,0,0,1,0,1,0,0,0],PolyVal [1,1,0,1,0,0,1,1,0,1,0,1,1,0,0,0],PolyVal [1,0,0,0,1,1,0,1,0,0,1,1,1,0,0,1],PolyVal [1,0,1,0,0,1,0,1,1,1,0,1,0,1,1,1]]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_p16(vcreate_p16(UINT64_C(0x09578c7088ddb0a6)),
                          vcreate_p16(UINT64_C(0xe23f4d5749aaaccb)));
      arg2 = vcombine_p16(vcreate_p16(UINT64_C(0x6a144a1488ca4797)),
                          vcreate_p16(UINT64_C(0xeba59cb11acb1457)));
      clear_neon_saturated();
      //  Expect: "result" = eba51acb6a1488cae23f49aa095788dd
      result = vuzp2q_p16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p16(result), 0);
         exp = UINT64_C(0xe23f49aa095788dd);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p16(result), 1);
         exp = UINT64_C(0xeba51acb6a1488ca);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_3218() {

{
   {
      float32x4_t arg1;
      float32x4_t arg2;
      float32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"uzp1\", fnname = \"vuzp1q_f32\", rettype = \"float32x4_t\", argtypes = \"[float32x4_t,float32x4_t]\", vals = [VectorVal [FloatVal 0.6622845530509949,FloatVal 0.6408644914627075,FloatVal 0.9988888502120972,FloatVal 8.340442180633545e-2],VectorVal [FloatVal 0.6529638171195984,FloatVal 5.4873108863830566e-2,FloatVal 0.11145234107971191,FloatVal 0.505221426486969]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_f32(vcreate_f32(UINT64_C(0x3f240fb23f298b7b)),
                          vcreate_f32(UINT64_C(0x3daacff03f7fb72e)));
      arg2 = vcombine_f32(vcreate_f32(UINT64_C(0x3d60c2a03f2728a3)),
                          vcreate_f32(UINT64_C(0x3f0156313de44120)));
      clear_neon_saturated();
      //  Expect: "result" = 3de441203f2728a33f7fb72e3f298b7b
      result = vuzp1q_f32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 0);
         exp = ((float32_t) 0.6622845530509949);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 1);
         exp = ((float32_t) 0.9988888502120972);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 2);
         exp = ((float32_t) 0.6529638171195984);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 2 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 3);
         exp = ((float32_t) 0.11145234107971191);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 3 ", exp, got);
            }
      }
   }
}
}
void dotests_3219() {

{
   {
      float32x4_t arg1;
      float32x4_t arg2;
      float32x4_t result;
      char* str1 = "ReproInfo2 {semantics = \"uzp2\", fnname = \"vuzp2q_f32\", rettype = \"float32x4_t\", argtypes = \"[float32x4_t,float32x4_t]\", vals = [VectorVal [FloatVal 0.33829641342163086,FloatVal 0.4922138452529907,FloatVal 0.2189827561378479,FloatVal 0.2994884252548218],VectorVal [FloatVal 0.43318140506744385,FloatVal 0.4486653804779053,FloatVal 0.12473195791244507,FloatVal 0.1371135115623474]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_f32(vcreate_f32(UINT64_C(0x3efc03743ead3530)),
                          vcreate_f32(UINT64_C(0x3e99568c3e603d04)));
      arg2 = vcombine_f32(vcreate_f32(UINT64_C(0x3ee5b7783eddc9f4)),
                          vcreate_f32(UINT64_C(0x3e0c677c3dff7378)));
      clear_neon_saturated();
      //  Expect: "result" = 3e0c677c3ee5b7783e99568c3efc0374
      result = vuzp2q_f32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 0);
         exp = ((float32_t) 0.4922138452529907);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 1);
         exp = ((float32_t) 0.2994884252548218);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 2);
         exp = ((float32_t) 0.4486653804779053);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 2 ", exp, got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result, 3);
         exp = ((float32_t) 0.1371135115623474);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 3 ", exp, got);
            }
      }
   }
}
}
void dotests_3220() {

{
   {
      float64x2_t arg1;
      float64x2_t arg2;
      float64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"uzp1\", fnname = \"vuzp1q_f64\", rettype = \"float64x2_t\", argtypes = \"[float64x2_t,float64x2_t]\", vals = [VectorVal [FloatVal 0.9511818547033343,FloatVal 7.972315647111727e-2],VectorVal [FloatVal 0.1399919470737886,FloatVal 1.3821435757556566e-2]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_f64(vcreate_f64(UINT64_C(0x3fee7014edcffb73)),
                          vcreate_f64(UINT64_C(0x3fb468bc9dc6ffb8)));
      arg2 = vcombine_f64(vcreate_f64(UINT64_C(0x3fc1eb4191315104)),
                          vcreate_f64(UINT64_C(0x3f8c4e69b47ff080)));
      clear_neon_saturated();
      //  Expect: "result" = 3fc1eb41913151043fee7014edcffb73
      result = vuzp1q_f64(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float64_t got;
         float64_t exp;
         got = vgetq_lane_f64(result, 0);
         exp = 0.9511818547033343;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float64_t got;
         float64_t exp;
         got = vgetq_lane_f64(result, 1);
         exp = 0.1399919470737886;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
   }
}
}
void dotests_3221() {

{
   {
      float64x2_t arg1;
      float64x2_t arg2;
      float64x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"uzp2\", fnname = \"vuzp2q_f64\", rettype = \"float64x2_t\", argtypes = \"[float64x2_t,float64x2_t]\", vals = [VectorVal [FloatVal 0.15680036282550658,FloatVal 0.5731320438982401],VectorVal [FloatVal 0.29622355344746976,FloatVal 0.28173061329730276]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_f64(vcreate_f64(UINT64_C(0x3fc41208c72b11f0)),
                          vcreate_f64(UINT64_C(0x3fe25719031aa47a)));
      arg2 = vcombine_f64(vcreate_f64(UINT64_C(0x3fd2f553a2972794)),
                          vcreate_f64(UINT64_C(0x3fd207dfd6993648)));
      clear_neon_saturated();
      //  Expect: "result" = 3fd207dfd69936483fe25719031aa47a
      result = vuzp2q_f64(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float64_t got;
         float64_t exp;
         got = vgetq_lane_f64(result, 0);
         exp = 0.5731320438982401;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
            }
      }
      {
         float64_t got;
         float64_t exp;
         got = vgetq_lane_f64(result, 1);
         exp = 0.28173061329730276;
         if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n", "   Lane 1 ", exp, got);
            }
      }
   }
}
}
void dotests_3222() {

{
   {
      int8x8_t arg1;
      int16_t result;
      char* str1 = "ReproInfo2 {semantics = \"addv\", fnname = \"vaddlv_s8\", rettype = \"int16_t\", argtypes = \"[int8x8_t]\", vals = [VectorVal [IntegerVal 127,IntegerVal 127,IntegerVal (-44),IntegerVal 0,IntegerVal 127,IntegerVal 127,IntegerVal (-128),IntegerVal 0]], start_saturated = False}";
      int reported = 0;
      int16_t got;
      int16_t exp;
      arg1 = vcreate_s8(UINT64_C(0x00807f7f00d47f7f));
      clear_neon_saturated();
      //  Expect: "result" = 0150
      result = vaddlv_s8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = 336;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIi16 " Got: %" PRIi16 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_3223() {

{
   {
      int16x4_t arg1;
      int32_t result;
      char* str1 = "ReproInfo2 {semantics = \"addv\", fnname = \"vaddlv_s16\", rettype = \"int32_t\", argtypes = \"[int16x4_t]\", vals = [VectorVal [IntegerVal 19784,IntegerVal 0,IntegerVal 17788,IntegerVal (-1)]], start_saturated = False}";
      int reported = 0;
      int32_t got;
      int32_t exp;
      arg1 = vcreate_s16(UINT64_C(0xffff457c00004d48));
      clear_neon_saturated();
      //  Expect: "result" = 000092c3
      result = vaddlv_s16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = 37571;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIi32 " Got: %" PRIi32 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_3224() {

{
   {
      uint8x8_t arg1;
      uint16_t result;
      char* str1 = "ReproInfo2 {semantics = \"addv\", fnname = \"vaddlv_u8\", rettype = \"uint16_t\", argtypes = \"[uint8x8_t]\", vals = [VectorVal [IntegerVal 128,IntegerVal 127,IntegerVal 255,IntegerVal 245,IntegerVal 255,IntegerVal 127,IntegerVal 146,IntegerVal 239]], start_saturated = False}";
      int reported = 0;
      uint16_t got;
      uint16_t exp;
      arg1 = vcreate_u8(UINT64_C(0xef927ffff5ff7f80));
      clear_neon_saturated();
      //  Expect: "result" = 05f2
      result = vaddlv_u8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = 1522U;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_3225() {

{
   {
      uint16x4_t arg1;
      uint32_t result;
      char* str1 = "ReproInfo2 {semantics = \"addv\", fnname = \"vaddlv_u16\", rettype = \"uint32_t\", argtypes = \"[uint16x4_t]\", vals = [VectorVal [IntegerVal 32767,IntegerVal 32767,IntegerVal 0,IntegerVal 65535]], start_saturated = False}";
      int reported = 0;
      uint32_t got;
      uint32_t exp;
      arg1 = vcreate_u16(UINT64_C(0xffff00007fff7fff));
      clear_neon_saturated();
      //  Expect: "result" = 0001fffd
      result = vaddlv_u16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = 131069U;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIu32 " Got: %" PRIu32 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_3226() {

{
   {
      int8x16_t arg1;
      int16_t result;
      char* str1 = "ReproInfo2 {semantics = \"addv\", fnname = \"vaddlvq_s8\", rettype = \"int16_t\", argtypes = \"[int8x16_t]\", vals = [VectorVal [IntegerVal 127,IntegerVal 125,IntegerVal (-1),IntegerVal (-1),IntegerVal (-13),IntegerVal 0,IntegerVal (-128),IntegerVal (-58),IntegerVal 0,IntegerVal 98,IntegerVal (-128),IntegerVal (-1),IntegerVal 0,IntegerVal (-1),IntegerVal 0,IntegerVal (-128)]], start_saturated = True}";
      int reported = 0;
      int16_t got;
      int16_t exp;
      arg1 = vcombine_s8(vcreate_s8(UINT64_C(0xc68000f3ffff7d7f)),
                         vcreate_s8(UINT64_C(0x8000ff00ff806200)));
      set_neon_saturated();
      //  Expect: "result" = ff93
      result = vaddlvq_s8(arg1);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      got = result;
      exp = -109;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIi16 " Got: %" PRIi16 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_3227() {

{
   {
      int16x8_t arg1;
      int32_t result;
      char* str1 = "ReproInfo2 {semantics = \"addv\", fnname = \"vaddlvq_s16\", rettype = \"int32_t\", argtypes = \"[int16x8_t]\", vals = [VectorVal [IntegerVal 32767,IntegerVal 0,IntegerVal 32767,IntegerVal 2774,IntegerVal (-6916),IntegerVal 32767,IntegerVal 10873,IntegerVal (-1)]], start_saturated = False}";
      int reported = 0;
      int32_t got;
      int32_t exp;
      arg1 = vcombine_s16(vcreate_s16(UINT64_C(0x0ad67fff00007fff)),
                          vcreate_s16(UINT64_C(0xffff2a797fffe4fc)));
      clear_neon_saturated();
      //  Expect: "result" = 00019a47
      result = vaddlvq_s16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = 105031;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIi32 " Got: %" PRIi32 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_3228() {

{
   {
      int32x4_t arg1;
      int64_t result;
      char* str1 = "ReproInfo2 {semantics = \"addv\", fnname = \"vaddlvq_s32\", rettype = \"int64_t\", argtypes = \"[int32x4_t]\", vals = [VectorVal [IntegerVal (-2147483648),IntegerVal (-844529664),IntegerVal 2147483647,IntegerVal 2147418112]], start_saturated = True}";
      int reported = 0;
      int64_t got;
      int64_t exp;
      arg1 = vcombine_s32(vcreate_s32(UINT64_C(0xcda9800080000000)),
                          vcreate_s32(UINT64_C(0x7fff00007fffffff)));
      set_neon_saturated();
      //  Expect: "result" = 000000004da87fff
      result = vaddlvq_s32(arg1);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      got = result;
      exp = INT64_C(1302888447);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIi64 " Got: %" PRIi64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_3229() {

{
   {
      uint8x16_t arg1;
      uint16_t result;
      char* str1 = "ReproInfo2 {semantics = \"addv\", fnname = \"vaddlvq_u8\", rettype = \"uint16_t\", argtypes = \"[uint8x16_t]\", vals = [VectorVal [IntegerVal 255,IntegerVal 255,IntegerVal 255,IntegerVal 255,IntegerVal 127,IntegerVal 255,IntegerVal 255,IntegerVal 127,IntegerVal 127,IntegerVal 69,IntegerVal 148,IntegerVal 255,IntegerVal 0,IntegerVal 255,IntegerVal 128,IntegerVal 255]], start_saturated = False}";
      int reported = 0;
      uint16_t got;
      uint16_t exp;
      arg1 = vcombine_u8(vcreate_u8(UINT64_C(0x7fffff7fffffffff)),
                         vcreate_u8(UINT64_C(0xff80ff00ff94457f)));
      clear_neon_saturated();
      //  Expect: "result" = 0bcd
      result = vaddlvq_u8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = 3021U;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_3230() {

{
   {
      uint16x8_t arg1;
      uint32_t result;
      char* str1 = "ReproInfo2 {semantics = \"addv\", fnname = \"vaddlvq_u16\", rettype = \"uint32_t\", argtypes = \"[uint16x8_t]\", vals = [VectorVal [IntegerVal 0,IntegerVal 33277,IntegerVal 32768,IntegerVal 0,IntegerVal 32768,IntegerVal 4661,IntegerVal 60531,IntegerVal 32768]], start_saturated = False}";
      int reported = 0;
      uint32_t got;
      uint32_t exp;
      arg1 = vcombine_u16(vcreate_u16(UINT64_C(0x0000800081fd0000)),
                          vcreate_u16(UINT64_C(0x8000ec7312358000)));
      clear_neon_saturated();
      //  Expect: "result" = 000300a5
      result = vaddlvq_u16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = 196773U;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIu32 " Got: %" PRIu32 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_3231() {

{
   {
      uint32x4_t arg1;
      uint64_t result;
      char* str1 = "ReproInfo2 {semantics = \"addv\", fnname = \"vaddlvq_u32\", rettype = \"uint64_t\", argtypes = \"[uint32x4_t]\", vals = [VectorVal [IntegerVal 4202567894,IntegerVal 2147516415,IntegerVal 46125,IntegerVal 4294967295]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcombine_u32(vcreate_u32(UINT64_C(0x80007ffffa7e18d6)),
                          vcreate_u32(UINT64_C(0xffffffff0000b42d)));
      clear_neon_saturated();
      //  Expect: "result" = 000000027a7f4d01
      result = vaddlvq_u32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = UINT64_C(0x000000027a7f4d01);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_3232() {

{
   {
      int8x8_t arg1;
      int8_t result;
      char* str1 = "ReproInfo2 {semantics = \"addv\", fnname = \"vaddv_s8\", rettype = \"int8_t\", argtypes = \"[int8x8_t]\", vals = [VectorVal [IntegerVal 127,IntegerVal 104,IntegerVal (-1),IntegerVal 127,IntegerVal 63,IntegerVal 20,IntegerVal 0,IntegerVal (-1)]], start_saturated = False}";
      int reported = 0;
      int8_t got;
      int8_t exp;
      arg1 = vcreate_s8(UINT64_C(0xff00143f7fff687f));
      clear_neon_saturated();
      //  Expect: "result" = b7
      result = vaddv_s8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = -73;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_3233() {

{
   {
      int16x4_t arg1;
      int16_t result;
      char* str1 = "ReproInfo2 {semantics = \"addv\", fnname = \"vaddv_s16\", rettype = \"int16_t\", argtypes = \"[int16x4_t]\", vals = [VectorVal [IntegerVal 14721,IntegerVal (-1),IntegerVal (-1),IntegerVal (-1)]], start_saturated = False}";
      int reported = 0;
      int16_t got;
      int16_t exp;
      arg1 = vcreate_s16(UINT64_C(0xffffffffffff3981));
      clear_neon_saturated();
      //  Expect: "result" = 397e
      result = vaddv_s16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = 14718;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIi16 " Got: %" PRIi16 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_3234() {

{
   {
      uint8x8_t arg1;
      uint8_t result;
      char* str1 = "ReproInfo2 {semantics = \"addv\", fnname = \"vaddv_u8\", rettype = \"uint8_t\", argtypes = \"[uint8x8_t]\", vals = [VectorVal [IntegerVal 128,IntegerVal 255,IntegerVal 127,IntegerVal 128,IntegerVal 0,IntegerVal 127,IntegerVal 128,IntegerVal 255]], start_saturated = False}";
      int reported = 0;
      uint8_t got;
      uint8_t exp;
      arg1 = vcreate_u8(UINT64_C(0xff807f00807fff80));
      clear_neon_saturated();
      //  Expect: "result" = 7c
      result = vaddv_u8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = 124U;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_3235() {

{
   {
      uint16x4_t arg1;
      uint16_t result;
      char* str1 = "ReproInfo2 {semantics = \"addv\", fnname = \"vaddv_u16\", rettype = \"uint16_t\", argtypes = \"[uint16x4_t]\", vals = [VectorVal [IntegerVal 65535,IntegerVal 0,IntegerVal 65535,IntegerVal 19885]], start_saturated = False}";
      int reported = 0;
      uint16_t got;
      uint16_t exp;
      arg1 = vcreate_u16(UINT64_C(0x4dadffff0000ffff));
      clear_neon_saturated();
      //  Expect: "result" = 4dab
      result = vaddv_u16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = 19883U;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_3236() {

{
   {
      int8x16_t arg1;
      int8_t result;
      char* str1 = "ReproInfo2 {semantics = \"addv\", fnname = \"vaddvq_s8\", rettype = \"int8_t\", argtypes = \"[int8x16_t]\", vals = [VectorVal [IntegerVal (-1),IntegerVal 0,IntegerVal (-1),IntegerVal 127,IntegerVal (-128),IntegerVal 0,IntegerVal (-128),IntegerVal (-128),IntegerVal (-128),IntegerVal 127,IntegerVal 127,IntegerVal 0,IntegerVal 0,IntegerVal (-128),IntegerVal (-1),IntegerVal (-128)]], start_saturated = False}";
      int reported = 0;
      int8_t got;
      int8_t exp;
      arg1 = vcombine_s8(vcreate_s8(UINT64_C(0x808000807fff00ff)),
                         vcreate_s8(UINT64_C(0x80ff8000007f7f80)));
      clear_neon_saturated();
      //  Expect: "result" = 7a
      result = vaddvq_s8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = 122;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_3237() {

{
   {
      int16x8_t arg1;
      int16_t result;
      char* str1 = "ReproInfo2 {semantics = \"addv\", fnname = \"vaddvq_s16\", rettype = \"int16_t\", argtypes = \"[int16x8_t]\", vals = [VectorVal [IntegerVal (-32768),IntegerVal 9998,IntegerVal 0,IntegerVal 0,IntegerVal (-32768),IntegerVal (-32768),IntegerVal 0,IntegerVal (-1)]], start_saturated = False}";
      int reported = 0;
      int16_t got;
      int16_t exp;
      arg1 = vcombine_s16(vcreate_s16(UINT64_C(0x00000000270e8000)),
                          vcreate_s16(UINT64_C(0xffff000080008000)));
      clear_neon_saturated();
      //  Expect: "result" = a70d
      result = vaddvq_s16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = -22771;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIi16 " Got: %" PRIi16 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_3238() {

{
   {
      int32x4_t arg1;
      int32_t result;
      char* str1 = "ReproInfo2 {semantics = \"addv\", fnname = \"vaddvq_s32\", rettype = \"int32_t\", argtypes = \"[int32x4_t]\", vals = [VectorVal [IntegerVal 2147450880,IntegerVal (-32768),IntegerVal 46989,IntegerVal 2147450879]], start_saturated = False}";
      int reported = 0;
      int32_t got;
      int32_t exp;
      arg1 = vcombine_s32(vcreate_s32(UINT64_C(0xffff80007fff8000)),
                          vcreate_s32(UINT64_C(0x7fff7fff0000b78d)));
      clear_neon_saturated();
      //  Expect: "result" = ffff378c
      result = vaddvq_s32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = -51316;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIi32 " Got: %" PRIi32 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_3239() {

{
   {
      uint8x16_t arg1;
      uint8_t result;
      char* str1 = "ReproInfo2 {semantics = \"addv\", fnname = \"vaddvq_u8\", rettype = \"uint8_t\", argtypes = \"[uint8x16_t]\", vals = [VectorVal [IntegerVal 128,IntegerVal 128,IntegerVal 127,IntegerVal 127,IntegerVal 0,IntegerVal 255,IntegerVal 74,IntegerVal 128,IntegerVal 255,IntegerVal 36,IntegerVal 121,IntegerVal 0,IntegerVal 255,IntegerVal 127,IntegerVal 127,IntegerVal 255]], start_saturated = False}";
      int reported = 0;
      uint8_t got;
      uint8_t exp;
      arg1 = vcombine_u8(vcreate_u8(UINT64_C(0x804aff007f7f8080)),
                         vcreate_u8(UINT64_C(0xff7f7fff007924ff)));
      clear_neon_saturated();
      //  Expect: "result" = 5f
      result = vaddvq_u8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = 95U;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_3240() {

{
   {
      uint16x8_t arg1;
      uint16_t result;
      char* str1 = "ReproInfo2 {semantics = \"addv\", fnname = \"vaddvq_u16\", rettype = \"uint16_t\", argtypes = \"[uint16x8_t]\", vals = [VectorVal [IntegerVal 32768,IntegerVal 25079,IntegerVal 32768,IntegerVal 32767,IntegerVal 0,IntegerVal 23268,IntegerVal 17101,IntegerVal 0]], start_saturated = False}";
      int reported = 0;
      uint16_t got;
      uint16_t exp;
      arg1 = vcombine_u16(vcreate_u16(UINT64_C(0x7fff800061f78000)),
                          vcreate_u16(UINT64_C(0x000042cd5ae40000)));
      clear_neon_saturated();
      //  Expect: "result" = 7fa7
      result = vaddvq_u16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = 32679U;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_3241() {

{
   {
      uint32x4_t arg1;
      uint32_t result;
      char* str1 = "ReproInfo2 {semantics = \"addv\", fnname = \"vaddvq_u32\", rettype = \"uint32_t\", argtypes = \"[uint32x4_t]\", vals = [VectorVal [IntegerVal 2147549183,IntegerVal 2147516415,IntegerVal 2147450879,IntegerVal 2147516415]], start_saturated = False}";
      int reported = 0;
      uint32_t got;
      uint32_t exp;
      arg1 = vcombine_u32(vcreate_u32(UINT64_C(0x80007fff8000ffff)),
                          vcreate_u32(UINT64_C(0x80007fff7fff7fff)));
      clear_neon_saturated();
      //  Expect: "result" = 00017ffc
      result = vaddvq_u32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = 98300U;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIu32 " Got: %" PRIu32 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_3242() {

{
   {
      int32x2_t arg1;
      int64_t result;
      char* str1 = "ReproInfo2 {semantics = \"addv\", fnname = \"vaddlv_s32\", rettype = \"int64_t\", argtypes = \"[int32x2_t]\", vals = [VectorVal [IntegerVal 2147450880,IntegerVal 2147442072]], start_saturated = False}";
      int reported = 0;
      int64_t got;
      int64_t exp;
      arg1 = vcreate_s32(UINT64_C(0x7fff5d987fff8000));
      clear_neon_saturated();
      //  Expect: "result" = 00000000fffedd98
      result = vaddlv_s32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = INT64_C(4294892952);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIi64 " Got: %" PRIi64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_3243() {

{
   {
      uint32x2_t arg1;
      uint64_t result;
      char* str1 = "ReproInfo2 {semantics = \"addv\", fnname = \"vaddlv_u32\", rettype = \"uint64_t\", argtypes = \"[uint32x2_t]\", vals = [VectorVal [IntegerVal 0,IntegerVal 4294967295]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u32(UINT64_C(0xffffffff00000000));
      clear_neon_saturated();
      //  Expect: "result" = 00000000ffffffff
      result = vaddlv_u32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = UINT64_C(0x00000000ffffffff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_3244() {

{
   {
      int8x8_t arg1;
      int8_t result;
      char* str1 = "ReproInfo2 {semantics = \"maxv\", fnname = \"vmaxv_s8\", rettype = \"int8_t\", argtypes = \"[int8x8_t]\", vals = [VectorVal [IntegerVal 127,IntegerVal 81,IntegerVal (-127),IntegerVal (-1),IntegerVal 0,IntegerVal 127,IntegerVal 127,IntegerVal (-128)]], start_saturated = False}";
      int reported = 0;
      int8_t got;
      int8_t exp;
      arg1 = vcreate_s8(UINT64_C(0x807f7f00ff81517f));
      clear_neon_saturated();
      //  Expect: "result" = 7f
      result = vmaxv_s8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = 127;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_3245() {

{
   {
      int16x4_t arg1;
      int16_t result;
      char* str1 = "ReproInfo2 {semantics = \"maxv\", fnname = \"vmaxv_s16\", rettype = \"int16_t\", argtypes = \"[int16x4_t]\", vals = [VectorVal [IntegerVal (-1),IntegerVal (-12653),IntegerVal 0,IntegerVal 32767]], start_saturated = False}";
      int reported = 0;
      int16_t got;
      int16_t exp;
      arg1 = vcreate_s16(UINT64_C(0x7fff0000ce93ffff));
      clear_neon_saturated();
      //  Expect: "result" = 7fff
      result = vmaxv_s16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = 32767;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIi16 " Got: %" PRIi16 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_3246() {

{
   {
      uint8x8_t arg1;
      uint8_t result;
      char* str1 = "ReproInfo2 {semantics = \"maxv\", fnname = \"vmaxv_u8\", rettype = \"uint8_t\", argtypes = \"[uint8x8_t]\", vals = [VectorVal [IntegerVal 0,IntegerVal 128,IntegerVal 0,IntegerVal 127,IntegerVal 0,IntegerVal 154,IntegerVal 255,IntegerVal 128]], start_saturated = False}";
      int reported = 0;
      uint8_t got;
      uint8_t exp;
      arg1 = vcreate_u8(UINT64_C(0x80ff9a007f008000));
      clear_neon_saturated();
      //  Expect: "result" = ff
      result = vmaxv_u8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = 255U;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_3247() {

{
   {
      uint16x4_t arg1;
      uint16_t result;
      char* str1 = "ReproInfo2 {semantics = \"maxv\", fnname = \"vmaxv_u16\", rettype = \"uint16_t\", argtypes = \"[uint16x4_t]\", vals = [VectorVal [IntegerVal 65535,IntegerVal 0,IntegerVal 65535,IntegerVal 32768]], start_saturated = False}";
      int reported = 0;
      uint16_t got;
      uint16_t exp;
      arg1 = vcreate_u16(UINT64_C(0x8000ffff0000ffff));
      clear_neon_saturated();
      //  Expect: "result" = ffff
      result = vmaxv_u16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = 65535U;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_3248() {

{
   {
      int8x16_t arg1;
      int8_t result;
      char* str1 = "ReproInfo2 {semantics = \"maxv\", fnname = \"vmaxvq_s8\", rettype = \"int8_t\", argtypes = \"[int8x16_t]\", vals = [VectorVal [IntegerVal 127,IntegerVal (-1),IntegerVal (-3),IntegerVal 127,IntegerVal 0,IntegerVal (-48),IntegerVal (-1),IntegerVal 0,IntegerVal 0,IntegerVal (-128),IntegerVal 127,IntegerVal 127,IntegerVal 45,IntegerVal 127,IntegerVal 0,IntegerVal 127]], start_saturated = False}";
      int reported = 0;
      int8_t got;
      int8_t exp;
      arg1 = vcombine_s8(vcreate_s8(UINT64_C(0x00ffd0007ffdff7f)),
                         vcreate_s8(UINT64_C(0x7f007f2d7f7f8000)));
      clear_neon_saturated();
      //  Expect: "result" = 7f
      result = vmaxvq_s8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = 127;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_3249() {

{
   {
      int16x8_t arg1;
      int16_t result;
      char* str1 = "ReproInfo2 {semantics = \"maxv\", fnname = \"vmaxvq_s16\", rettype = \"int16_t\", argtypes = \"[int16x8_t]\", vals = [VectorVal [IntegerVal 5427,IntegerVal 32767,IntegerVal (-1),IntegerVal (-12758),IntegerVal (-1),IntegerVal (-1),IntegerVal 32767,IntegerVal 0]], start_saturated = True}";
      int reported = 0;
      int16_t got;
      int16_t exp;
      arg1 = vcombine_s16(vcreate_s16(UINT64_C(0xce2affff7fff1533)),
                          vcreate_s16(UINT64_C(0x00007fffffffffff)));
      set_neon_saturated();
      //  Expect: "result" = 7fff
      result = vmaxvq_s16(arg1);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      got = result;
      exp = 32767;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIi16 " Got: %" PRIi16 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_3250() {

{
   {
      int32x4_t arg1;
      int32_t result;
      char* str1 = "ReproInfo2 {semantics = \"maxv\", fnname = \"vmaxvq_s32\", rettype = \"int32_t\", argtypes = \"[int32x4_t]\", vals = [VectorVal [IntegerVal 32768,IntegerVal 1645510655,IntegerVal 243705067,IntegerVal (-1206059009)]], start_saturated = False}";
      int reported = 0;
      int32_t got;
      int32_t exp;
      arg1 = vcombine_s32(vcreate_s32(UINT64_C(0x62147fff00008000)),
                          vcreate_s32(UINT64_C(0xb81cffff0e86a4eb)));
      clear_neon_saturated();
      //  Expect: "result" = 62147fff
      result = vmaxvq_s32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = 1645510655;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIi32 " Got: %" PRIi32 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_3251() {

{
   {
      uint8x16_t arg1;
      uint8_t result;
      char* str1 = "ReproInfo2 {semantics = \"maxv\", fnname = \"vmaxvq_u8\", rettype = \"uint8_t\", argtypes = \"[uint8x16_t]\", vals = [VectorVal [IntegerVal 127,IntegerVal 127,IntegerVal 0,IntegerVal 128,IntegerVal 0,IntegerVal 0,IntegerVal 89,IntegerVal 0,IntegerVal 128,IntegerVal 128,IntegerVal 127,IntegerVal 0,IntegerVal 91,IntegerVal 40,IntegerVal 118,IntegerVal 255]], start_saturated = False}";
      int reported = 0;
      uint8_t got;
      uint8_t exp;
      arg1 = vcombine_u8(vcreate_u8(UINT64_C(0x0059000080007f7f)),
                         vcreate_u8(UINT64_C(0xff76285b007f8080)));
      clear_neon_saturated();
      //  Expect: "result" = ff
      result = vmaxvq_u8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = 255U;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_3252() {

{
   {
      uint16x8_t arg1;
      uint16_t result;
      char* str1 = "ReproInfo2 {semantics = \"maxv\", fnname = \"vmaxvq_u16\", rettype = \"uint16_t\", argtypes = \"[uint16x8_t]\", vals = [VectorVal [IntegerVal 32767,IntegerVal 32768,IntegerVal 33938,IntegerVal 32768,IntegerVal 32768,IntegerVal 32767,IntegerVal 32768,IntegerVal 3416]], start_saturated = False}";
      int reported = 0;
      uint16_t got;
      uint16_t exp;
      arg1 = vcombine_u16(vcreate_u16(UINT64_C(0x8000849280007fff)),
                          vcreate_u16(UINT64_C(0x0d5880007fff8000)));
      clear_neon_saturated();
      //  Expect: "result" = 8492
      result = vmaxvq_u16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = 33938U;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_3253() {

{
   {
      uint32x4_t arg1;
      uint32_t result;
      char* str1 = "ReproInfo2 {semantics = \"maxv\", fnname = \"vmaxvq_u32\", rettype = \"uint32_t\", argtypes = \"[uint32x4_t]\", vals = [VectorVal [IntegerVal 2147498574,IntegerVal 3714285567,IntegerVal 2743402496,IntegerVal 2147516416]], start_saturated = False}";
      int reported = 0;
      uint32_t got;
      uint32_t exp;
      arg1 = vcombine_u32(vcreate_u32(UINT64_C(0xdd637fff80003a4e)),
                          vcreate_u32(UINT64_C(0x80008000a3850000)));
      clear_neon_saturated();
      //  Expect: "result" = dd637fff
      result = vmaxvq_u32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = 3714285567U;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIu32 " Got: %" PRIu32 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_3254() {

{
   {
      float32x4_t arg1;
      float32_t result;
      char* str1 = "ReproInfo2 {semantics = \"maxv\", fnname = \"vmaxvq_f32\", rettype = \"float32_t\", argtypes = \"[float32x4_t]\", vals = [VectorVal [FloatVal 0.6389937996864319,FloatVal 0.6940295696258545,FloatVal 0.7066637873649597,FloatVal 0.6071353554725647]], start_saturated = False}";
      int reported = 0;
      float32_t got;
      float32_t exp;
      arg1 = vcombine_f32(vcreate_f32(UINT64_C(0x3f31abec3f239519)),
                          vcreate_f32(UINT64_C(0x3f1b6d393f34e7eb)));
      clear_neon_saturated();
      //  Expect: "result" = 3f34e7eb
      result = vmaxvq_f32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = ((float32_t) 0.7066637873649597);
      if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %f Got: %f\n", "   ", exp, got);
         }
   }
}
}
void dotests_3255() {

{
   {
      float32x4_t arg1;
      float32_t result;
      char* str1 = "ReproInfo2 {semantics = \"maxvnm\", fnname = \"vmaxnmvq_f32\", rettype = \"float32_t\", argtypes = \"[float32x4_t]\", vals = [VectorVal [FloatVal 0.11307775974273682,FloatVal 0.738274872303009,FloatVal 0.8592735528945923,FloatVal 0.5369063019752502]], start_saturated = False}";
      int reported = 0;
      float32_t got;
      float32_t exp;
      arg1 = vcombine_f32(vcreate_f32(UINT64_C(0x3f3cff953de79550)),
                          vcreate_f32(UINT64_C(0x3f0972b13f5bf95a)));
      clear_neon_saturated();
      //  Expect: "result" = 3f5bf95a
      result = vmaxnmvq_f32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = ((float32_t) 0.8592735528945923);
      if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %f Got: %f\n", "   ", exp, got);
         }
   }
}
}
void dotests_3256() {

{
   {
      int8x8_t arg1;
      int8_t result;
      char* str1 = "ReproInfo2 {semantics = \"minv\", fnname = \"vminv_s8\", rettype = \"int8_t\", argtypes = \"[int8x8_t]\", vals = [VectorVal [IntegerVal 0,IntegerVal (-1),IntegerVal (-1),IntegerVal 127,IntegerVal 127,IntegerVal (-1),IntegerVal (-1),IntegerVal 33]], start_saturated = False}";
      int reported = 0;
      int8_t got;
      int8_t exp;
      arg1 = vcreate_s8(UINT64_C(0x21ffff7f7fffff00));
      clear_neon_saturated();
      //  Expect: "result" = ff
      result = vminv_s8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = -1;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_3257() {

{
   {
      int16x4_t arg1;
      int16_t result;
      char* str1 = "ReproInfo2 {semantics = \"minv\", fnname = \"vminv_s16\", rettype = \"int16_t\", argtypes = \"[int16x4_t]\", vals = [VectorVal [IntegerVal 0,IntegerVal 32767,IntegerVal 32767,IntegerVal 0]], start_saturated = False}";
      int reported = 0;
      int16_t got;
      int16_t exp;
      arg1 = vcreate_s16(UINT64_C(0x00007fff7fff0000));
      clear_neon_saturated();
      //  Expect: "result" = 0000
      result = vminv_s16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = 0;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIi16 " Got: %" PRIi16 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_3258() {

{
   {
      uint8x8_t arg1;
      uint8_t result;
      char* str1 = "ReproInfo2 {semantics = \"minv\", fnname = \"vminv_u8\", rettype = \"uint8_t\", argtypes = \"[uint8x8_t]\", vals = [VectorVal [IntegerVal 129,IntegerVal 255,IntegerVal 255,IntegerVal 128,IntegerVal 7,IntegerVal 207,IntegerVal 0,IntegerVal 128]], start_saturated = False}";
      int reported = 0;
      uint8_t got;
      uint8_t exp;
      arg1 = vcreate_u8(UINT64_C(0x8000cf0780ffff81));
      clear_neon_saturated();
      //  Expect: "result" = 00
      result = vminv_u8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = 0;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_3259() {

{
   {
      uint16x4_t arg1;
      uint16_t result;
      char* str1 = "ReproInfo2 {semantics = \"minv\", fnname = \"vminv_u16\", rettype = \"uint16_t\", argtypes = \"[uint16x4_t]\", vals = [VectorVal [IntegerVal 65535,IntegerVal 0,IntegerVal 0,IntegerVal 32767]], start_saturated = True}";
      int reported = 0;
      uint16_t got;
      uint16_t exp;
      arg1 = vcreate_u16(UINT64_C(0x7fff00000000ffff));
      set_neon_saturated();
      //  Expect: "result" = 0000
      result = vminv_u16(arg1);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      got = result;
      exp = 0;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_3260() {

{
   {
      int8x16_t arg1;
      int8_t result;
      char* str1 = "ReproInfo2 {semantics = \"minv\", fnname = \"vminvq_s8\", rettype = \"int8_t\", argtypes = \"[int8x16_t]\", vals = [VectorVal [IntegerVal (-1),IntegerVal (-128),IntegerVal (-1),IntegerVal 0,IntegerVal 127,IntegerVal (-114),IntegerVal (-1),IntegerVal (-128),IntegerVal 127,IntegerVal 0,IntegerVal 127,IntegerVal 127,IntegerVal (-128),IntegerVal 0,IntegerVal 0,IntegerVal (-57)]], start_saturated = False}";
      int reported = 0;
      int8_t got;
      int8_t exp;
      arg1 = vcombine_s8(vcreate_s8(UINT64_C(0x80ff8e7f00ff80ff)),
                         vcreate_s8(UINT64_C(0xc70000807f7f007f)));
      clear_neon_saturated();
      //  Expect: "result" = 80
      result = vminvq_s8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = -128;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIi8 " Got: %" PRIi8 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_3261() {

{
   {
      int16x8_t arg1;
      int16_t result;
      char* str1 = "ReproInfo2 {semantics = \"minv\", fnname = \"vminvq_s16\", rettype = \"int16_t\", argtypes = \"[int16x8_t]\", vals = [VectorVal [IntegerVal (-7446),IntegerVal 845,IntegerVal 32767,IntegerVal 13138,IntegerVal (-32768),IntegerVal (-32768),IntegerVal (-32768),IntegerVal (-32768)]], start_saturated = False}";
      int reported = 0;
      int16_t got;
      int16_t exp;
      arg1 = vcombine_s16(vcreate_s16(UINT64_C(0x33527fff034de2ea)),
                          vcreate_s16(UINT64_C(0x8000800080008000)));
      clear_neon_saturated();
      //  Expect: "result" = 8000
      result = vminvq_s16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = -32768;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIi16 " Got: %" PRIi16 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_3262() {

{
   {
      int32x4_t arg1;
      int32_t result;
      char* str1 = "ReproInfo2 {semantics = \"minv\", fnname = \"vminvq_s32\", rettype = \"int32_t\", argtypes = \"[int32x4_t]\", vals = [VectorVal [IntegerVal (-1711472641),IntegerVal (-32769),IntegerVal 2147450880,IntegerVal 65535]], start_saturated = False}";
      int reported = 0;
      int32_t got;
      int32_t exp;
      arg1 = vcombine_s32(vcreate_s32(UINT64_C(0xffff7fff99fcffff)),
                          vcreate_s32(UINT64_C(0x0000ffff7fff8000)));
      clear_neon_saturated();
      //  Expect: "result" = 99fcffff
      result = vminvq_s32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = -1711472641;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIi32 " Got: %" PRIi32 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_3263() {

{
   {
      uint8x16_t arg1;
      uint8_t result;
      char* str1 = "ReproInfo2 {semantics = \"minv\", fnname = \"vminvq_u8\", rettype = \"uint8_t\", argtypes = \"[uint8x16_t]\", vals = [VectorVal [IntegerVal 127,IntegerVal 0,IntegerVal 128,IntegerVal 0,IntegerVal 117,IntegerVal 0,IntegerVal 245,IntegerVal 255,IntegerVal 127,IntegerVal 127,IntegerVal 255,IntegerVal 128,IntegerVal 33,IntegerVal 127,IntegerVal 255,IntegerVal 255]], start_saturated = False}";
      int reported = 0;
      uint8_t got;
      uint8_t exp;
      arg1 = vcombine_u8(vcreate_u8(UINT64_C(0xfff500750080007f)),
                         vcreate_u8(UINT64_C(0xffff7f2180ff7f7f)));
      clear_neon_saturated();
      //  Expect: "result" = 00
      result = vminvq_u8(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = 0;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIu8 " Got: %" PRIu8 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_3264() {

{
   {
      uint16x8_t arg1;
      uint16_t result;
      char* str1 = "ReproInfo2 {semantics = \"minv\", fnname = \"vminvq_u16\", rettype = \"uint16_t\", argtypes = \"[uint16x8_t]\", vals = [VectorVal [IntegerVal 21193,IntegerVal 19865,IntegerVal 12681,IntegerVal 32767,IntegerVal 29517,IntegerVal 0,IntegerVal 32767,IntegerVal 0]], start_saturated = False}";
      int reported = 0;
      uint16_t got;
      uint16_t exp;
      arg1 = vcombine_u16(vcreate_u16(UINT64_C(0x7fff31894d9952c9)),
                          vcreate_u16(UINT64_C(0x00007fff0000734d)));
      clear_neon_saturated();
      //  Expect: "result" = 0000
      result = vminvq_u16(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = 0;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIu16 " Got: %" PRIu16 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_3265() {

{
   {
      uint32x4_t arg1;
      uint32_t result;
      char* str1 = "ReproInfo2 {semantics = \"minv\", fnname = \"vminvq_u32\", rettype = \"uint32_t\", argtypes = \"[uint32x4_t]\", vals = [VectorVal [IntegerVal 2147505125,IntegerVal 2147483647,IntegerVal 2147429512,IntegerVal 2147441967]], start_saturated = False}";
      int reported = 0;
      uint32_t got;
      uint32_t exp;
      arg1 = vcombine_u32(vcreate_u32(UINT64_C(0x7fffffff800053e5)),
                          vcreate_u32(UINT64_C(0x7fff5d2f7fff2c88)));
      clear_neon_saturated();
      //  Expect: "result" = 7fff2c88
      result = vminvq_u32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = 2147429512U;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIu32 " Got: %" PRIu32 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_3266() {

{
   {
      float32x4_t arg1;
      float32_t result;
      char* str1 = "ReproInfo2 {semantics = \"minv\", fnname = \"vminvq_f32\", rettype = \"float32_t\", argtypes = \"[float32x4_t]\", vals = [VectorVal [FloatVal 0.36512500047683716,FloatVal 0.2203657031059265,FloatVal 0.5877910852432251,FloatVal 0.555242121219635]], start_saturated = False}";
      int reported = 0;
      float32_t got;
      float32_t exp;
      arg1 = vcombine_f32(vcreate_f32(UINT64_C(0x3e61a78c3ebaf1aa)),
                          vcreate_f32(UINT64_C(0x3f0e24593f16797a)));
      clear_neon_saturated();
      //  Expect: "result" = 3e61a78c
      result = vminvq_f32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = ((float32_t) 0.2203657031059265);
      if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %f Got: %f\n", "   ", exp, got);
         }
   }
}
}
void dotests_3267() {

{
   {
      float32x4_t arg1;
      float32_t result;
      char* str1 = "ReproInfo2 {semantics = \"minvnm\", fnname = \"vminnmvq_f32\", rettype = \"float32_t\", argtypes = \"[float32x4_t]\", vals = [VectorVal [FloatVal 0.2883668541908264,FloatVal 0.764336109161377,FloatVal 0.908991813659668,FloatVal 0.5485931038856506]], start_saturated = True}";
      int reported = 0;
      float32_t got;
      float32_t exp;
      arg1 = vcombine_f32(vcreate_f32(UINT64_C(0x3f43ab883e93a4d2)),
                          vcreate_f32(UINT64_C(0x3f0c70993f68b3b0)));
      set_neon_saturated();
      //  Expect: "result" = 3e93a4d2
      result = vminnmvq_f32(arg1);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      got = result;
      exp = ((float32_t) 0.2883668541908264);
      if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %f Got: %f\n", "   ", exp, got);
         }
   }
}
}
void dotests_3268() {

{
   {
      float64x1_t arg1;
      float64x1_t result;
      char* str1 = "ReproInfo2 {semantics = \"set_all_lanes_lane\", fnname = \"vdup_lane_f64\", rettype = \"float64x1_t\", argtypes = \"[float64x1_t,__constrange(0,0) int]\", vals = [VectorVal [FloatVal 3.704960043620764e-2],IndexVal 0], start_saturated = False}";
      int reported = 0;
      float64_t got;
      float64_t exp;
      arg1 = vcreate_f64(UINT64_C(0x3fa2f82a4c682150));
      clear_neon_saturated();
      //  Expect: "result" = 3fa2f82a4c682150
      result = vdup_lane_f64(arg1, 0);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_f64(result, 0);
      exp = 3.704960043620764e-2;
      if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %f Got: %f\n", "   Lane 0 ", exp, got);
         }
   }
}
}
void dotests_3269() {

{
   {
      uint8x8_t arg1;
      uint8x8_t arg2;
      uint8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"tbl\", fnname = \"vtbl1_u8\", rettype = \"uint8x8_t\", argtypes = \"[uint8x8_t,uint8x8_t]\", vals = [VectorVal [IntegerVal 255,IntegerVal 127,IntegerVal 128,IntegerVal 128,IntegerVal 32,IntegerVal 128,IntegerVal 128,IntegerVal 255],VectorVal [IntegerVal 127,IntegerVal 128,IntegerVal 127,IntegerVal 255,IntegerVal 127,IntegerVal 127,IntegerVal 0,IntegerVal 0]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u8(UINT64_C(0xff80802080807fff));
      arg2 = vcreate_u8(UINT64_C(0x00007f7fff7f807f));
      clear_neon_saturated();
      //  Expect: "result" = ffff000000000000
      result = vtbl1_u8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u8(result), 0);
      exp = UINT64_C(0xffff000000000000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_3270() {

{
   {
      int8x8_t arg1;
      int8x8_t arg2;
      int8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"tbl\", fnname = \"vtbl1_s8\", rettype = \"int8x8_t\", argtypes = \"[int8x8_t,int8x8_t]\", vals = [VectorVal [IntegerVal (-20),IntegerVal (-7),IntegerVal (-116),IntegerVal (-57),IntegerVal (-109),IntegerVal 0,IntegerVal 0,IntegerVal 29],VectorVal [IntegerVal 0,IntegerVal (-1),IntegerVal 0,IntegerVal 0,IntegerVal (-128),IntegerVal (-128),IntegerVal (-1),IntegerVal (-128)]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s8(UINT64_C(0x1d000093c78cf9ec));
      arg2 = vcreate_s8(UINT64_C(0x80ff80800000ff00));
      clear_neon_saturated();
      //  Expect: "result" = 00000000ecec00ec
      result = vtbl1_s8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s8(result), 0);
      exp = UINT64_C(0x00000000ecec00ec);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_3271() {

{
   {
      poly8x8_t arg1;
      uint8x8_t arg2;
      poly8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"tbl\", fnname = \"vtbl1_p8\", rettype = \"poly8x8_t\", argtypes = \"[poly8x8_t,uint8x8_t]\", vals = [VectorVal [PolyVal [0,1,0,1,0,0,0,0],PolyVal [0,0,1,0,1,1,1,1],PolyVal [0,1,0,0,0,1,0,1],PolyVal [0,1,1,1,0,1,0,0],PolyVal [0,0,0,0,1,0,1,0],PolyVal [1,0,0,1,0,1,1,0],PolyVal [0,1,0,1,1,0,1,1],PolyVal [1,0,1,1,0,0,0,0]],VectorVal [IntegerVal 128,IntegerVal 255,IntegerVal 7,IntegerVal 42,IntegerVal 0,IntegerVal 255,IntegerVal 128,IntegerVal 128]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_p8(UINT64_C(0x0dda69502ea2f40a));
      arg2 = vcreate_u8(UINT64_C(0x8080ff002a07ff80));
      clear_neon_saturated();
      //  Expect: "result" = 0000000a000d0000
      result = vtbl1_p8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_p8(result), 0);
      exp = UINT64_C(0x0000000a000d0000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_3272() {

{
   {
      uint8x8x2_t arg1;
      uint8x8_t arg2;
      uint8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"tbl\", fnname = \"vtbl2_u8\", rettype = \"uint8x8_t\", argtypes = \"[uint8x8x2_t,uint8x8_t]\", vals = [ArrayVal [VectorVal [IntegerVal 127,IntegerVal 127,IntegerVal 128,IntegerVal 0,IntegerVal 244,IntegerVal 255,IntegerVal 128,IntegerVal 127],VectorVal [IntegerVal 0,IntegerVal 128,IntegerVal 127,IntegerVal 128,IntegerVal 127,IntegerVal 128,IntegerVal 230,IntegerVal 128]],VectorVal [IntegerVal 128,IntegerVal 255,IntegerVal 127,IntegerVal 112,IntegerVal 127,IntegerVal 0,IntegerVal 255,IntegerVal 238]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1.val[0] = vcreate_u8(UINT64_C(0x7f80fff400807f7f));
      arg1.val[1] = vcreate_u8(UINT64_C(0x80e6807f807f8000));
      arg2 = vcreate_u8(UINT64_C(0xeeff007f707fff80));
      clear_neon_saturated();
      //  Expect: "result" = 00007f0000000000
      result = vtbl2_u8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u8(result), 0);
      exp = UINT64_C(0x00007f0000000000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_3273() {

{
   {
      int8x8x2_t arg1;
      int8x8_t arg2;
      int8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"tbl\", fnname = \"vtbl2_s8\", rettype = \"int8x8_t\", argtypes = \"[int8x8x2_t,int8x8_t]\", vals = [ArrayVal [VectorVal [IntegerVal (-128),IntegerVal 0,IntegerVal 0,IntegerVal 12,IntegerVal (-128),IntegerVal (-128),IntegerVal 0,IntegerVal (-61)],VectorVal [IntegerVal (-1),IntegerVal 0,IntegerVal (-128),IntegerVal 15,IntegerVal 127,IntegerVal (-1),IntegerVal 127,IntegerVal (-128)]],VectorVal [IntegerVal 127,IntegerVal (-1),IntegerVal (-112),IntegerVal 97,IntegerVal (-1),IntegerVal (-65),IntegerVal (-86),IntegerVal 0]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1.val[0] = vcreate_s8(UINT64_C(0xc30080800c000080));
      arg1.val[1] = vcreate_s8(UINT64_C(0x807fff7f0f8000ff));
      arg2 = vcreate_s8(UINT64_C(0x00aabfff6190ff7f));
      clear_neon_saturated();
      //  Expect: "result" = 8000000000000000
      result = vtbl2_s8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s8(result), 0);
      exp = UINT64_C(0x8000000000000000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_3274() {

{
   {
      poly8x8x2_t arg1;
      uint8x8_t arg2;
      poly8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"tbl\", fnname = \"vtbl2_p8\", rettype = \"poly8x8_t\", argtypes = \"[poly8x8x2_t,uint8x8_t]\", vals = [ArrayVal [VectorVal [PolyVal [1,1,1,1,1,0,1,1],PolyVal [0,0,0,0,1,1,1,1],PolyVal [0,1,1,0,0,1,0,1],PolyVal [0,0,0,1,0,0,0,1],PolyVal [1,1,0,0,0,1,0,1],PolyVal [0,0,0,0,0,1,1,0],PolyVal [1,1,1,0,0,0,1,1],PolyVal [0,0,1,1,1,1,0,0]],VectorVal [PolyVal [0,0,0,1,0,1,0,0],PolyVal [0,0,0,1,1,1,0,0],PolyVal [1,0,0,0,0,0,1,1],PolyVal [0,1,1,1,0,1,0,0],PolyVal [1,0,0,1,1,1,1,0],PolyVal [0,1,0,0,1,0,1,0],PolyVal [1,1,1,1,1,0,0,0],PolyVal [1,0,1,0,0,0,0,0]]],VectorVal [IntegerVal 255,IntegerVal 255,IntegerVal 128,IntegerVal 0,IntegerVal 0,IntegerVal 127,IntegerVal 114,IntegerVal 127]], start_saturated = True}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1.val[0] = vcreate_p8(UINT64_C(0x3cc760a388a6f0df));
      arg1.val[1] = vcreate_p8(UINT64_C(0x051f52792ec13828));
      arg2 = vcreate_u8(UINT64_C(0x7f727f000080ffff));
      set_neon_saturated();
      //  Expect: "result" = 000000dfdf000000
      result = vtbl2_p8(arg1, arg2);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_p8(result), 0);
      exp = UINT64_C(0x000000dfdf000000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_3275() {

{
   {
      uint8x8x3_t arg1;
      uint8x8_t arg2;
      uint8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"tbl\", fnname = \"vtbl3_u8\", rettype = \"uint8x8_t\", argtypes = \"[uint8x8x3_t,uint8x8_t]\", vals = [ArrayVal [VectorVal [IntegerVal 127,IntegerVal 127,IntegerVal 243,IntegerVal 0,IntegerVal 128,IntegerVal 255,IntegerVal 0,IntegerVal 188],VectorVal [IntegerVal 68,IntegerVal 255,IntegerVal 128,IntegerVal 7,IntegerVal 128,IntegerVal 255,IntegerVal 0,IntegerVal 127],VectorVal [IntegerVal 128,IntegerVal 127,IntegerVal 127,IntegerVal 127,IntegerVal 128,IntegerVal 0,IntegerVal 127,IntegerVal 255]],VectorVal [IntegerVal 127,IntegerVal 156,IntegerVal 255,IntegerVal 127,IntegerVal 127,IntegerVal 127,IntegerVal 128,IntegerVal 255]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1.val[0] = vcreate_u8(UINT64_C(0xbc00ff8000f37f7f));
      arg1.val[1] = vcreate_u8(UINT64_C(0x7f00ff800780ff44));
      arg1.val[2] = vcreate_u8(UINT64_C(0xff7f00807f7f7f80));
      arg2 = vcreate_u8(UINT64_C(0xff807f7f7fff9c7f));
      clear_neon_saturated();
      //  Expect: "result" = 0000000000000000
      result = vtbl3_u8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u8(result), 0);
      exp = 0;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_3276() {

{
   {
      int8x8x3_t arg1;
      int8x8_t arg2;
      int8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"tbl\", fnname = \"vtbl3_s8\", rettype = \"int8x8_t\", argtypes = \"[int8x8x3_t,int8x8_t]\", vals = [ArrayVal [VectorVal [IntegerVal (-75),IntegerVal (-95),IntegerVal 0,IntegerVal (-25),IntegerVal (-1),IntegerVal (-12),IntegerVal 127,IntegerVal 0],VectorVal [IntegerVal 127,IntegerVal (-128),IntegerVal 127,IntegerVal (-128),IntegerVal (-128),IntegerVal 15,IntegerVal (-1),IntegerVal (-128)],VectorVal [IntegerVal (-1),IntegerVal (-128),IntegerVal (-1),IntegerVal (-1),IntegerVal (-1),IntegerVal 47,IntegerVal (-128),IntegerVal (-128)]],VectorVal [IntegerVal 0,IntegerVal 127,IntegerVal (-1),IntegerVal (-1),IntegerVal (-128),IntegerVal (-128),IntegerVal (-74),IntegerVal (-1)]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1.val[0] = vcreate_s8(UINT64_C(0x007ff4ffe700a1b5));
      arg1.val[1] = vcreate_s8(UINT64_C(0x80ff0f80807f807f));
      arg1.val[2] = vcreate_s8(UINT64_C(0x80802fffffff80ff));
      arg2 = vcreate_s8(UINT64_C(0xffb68080ffff7f00));
      clear_neon_saturated();
      //  Expect: "result" = 00000000000000b5
      result = vtbl3_s8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s8(result), 0);
      exp = UINT64_C(0x00000000000000b5);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_3277() {

{
   {
      poly8x8x3_t arg1;
      uint8x8_t arg2;
      poly8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"tbl\", fnname = \"vtbl3_p8\", rettype = \"poly8x8_t\", argtypes = \"[poly8x8x3_t,uint8x8_t]\", vals = [ArrayVal [VectorVal [PolyVal [1,1,0,1,0,0,1,1],PolyVal [1,0,1,0,0,0,0,0],PolyVal [1,1,0,0,0,0,0,1],PolyVal [0,1,0,0,0,0,0,1],PolyVal [1,0,1,0,0,0,1,1],PolyVal [1,1,0,0,0,0,1,1],PolyVal [1,0,1,0,0,1,1,1],PolyVal [1,1,1,1,1,0,0,0]],VectorVal [PolyVal [0,0,0,0,0,0,1,1],PolyVal [1,0,1,0,1,1,0,0],PolyVal [0,1,0,0,1,0,1,0],PolyVal [1,1,0,1,1,0,1,1],PolyVal [1,1,0,0,0,1,1,0],PolyVal [0,0,1,0,0,0,0,0],PolyVal [1,1,1,0,0,0,1,0],PolyVal [1,0,1,0,0,0,0,0]],VectorVal [PolyVal [1,0,0,0,0,0,0,0],PolyVal [0,0,0,1,0,1,1,0],PolyVal [1,0,1,1,0,1,1,0],PolyVal [0,0,0,0,0,0,0,0],PolyVal [1,0,1,1,0,0,1,1],PolyVal [1,0,0,1,1,1,0,1],PolyVal [1,1,0,0,0,1,1,1],PolyVal [0,0,0,1,1,1,0,1]]],VectorVal [IntegerVal 128,IntegerVal 0,IntegerVal 255,IntegerVal 67,IntegerVal 127,IntegerVal 255,IntegerVal 255,IntegerVal 0]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1.val[0] = vcreate_p8(UINT64_C(0x1fe5c3c5828305cb));
      arg1.val[1] = vcreate_p8(UINT64_C(0x05470463db5235c0));
      arg1.val[2] = vcreate_p8(UINT64_C(0xb8e3b9cd006d6801));
      arg2 = vcreate_u8(UINT64_C(0x00ffff7f43ff0080));
      clear_neon_saturated();
      //  Expect: "result" = cb0000000000cb00
      result = vtbl3_p8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_p8(result), 0);
      exp = UINT64_C(0xcb0000000000cb00);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_3278() {

{
   {
      uint8x8x4_t arg1;
      uint8x8_t arg2;
      uint8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"tbl\", fnname = \"vtbl4_u8\", rettype = \"uint8x8_t\", argtypes = \"[uint8x8x4_t,uint8x8_t]\", vals = [ArrayVal [VectorVal [IntegerVal 2,IntegerVal 0,IntegerVal 128,IntegerVal 255,IntegerVal 0,IntegerVal 0,IntegerVal 234,IntegerVal 0],VectorVal [IntegerVal 255,IntegerVal 255,IntegerVal 0,IntegerVal 144,IntegerVal 127,IntegerVal 255,IntegerVal 128,IntegerVal 255],VectorVal [IntegerVal 128,IntegerVal 128,IntegerVal 128,IntegerVal 224,IntegerVal 127,IntegerVal 255,IntegerVal 0,IntegerVal 0],VectorVal [IntegerVal 127,IntegerVal 128,IntegerVal 123,IntegerVal 127,IntegerVal 127,IntegerVal 128,IntegerVal 169,IntegerVal 127]],VectorVal [IntegerVal 73,IntegerVal 50,IntegerVal 127,IntegerVal 0,IntegerVal 127,IntegerVal 255,IntegerVal 255,IntegerVal 0]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1.val[0] = vcreate_u8(UINT64_C(0x00ea0000ff800002));
      arg1.val[1] = vcreate_u8(UINT64_C(0xff80ff7f9000ffff));
      arg1.val[2] = vcreate_u8(UINT64_C(0x0000ff7fe0808080));
      arg1.val[3] = vcreate_u8(UINT64_C(0x7fa9807f7f7b807f));
      arg2 = vcreate_u8(UINT64_C(0x00ffff7f007f3249));
      clear_neon_saturated();
      //  Expect: "result" = 0200000002000000
      result = vtbl4_u8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u8(result), 0);
      exp = UINT64_C(0x0200000002000000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_3279() {

{
   {
      int8x8x4_t arg1;
      int8x8_t arg2;
      int8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"tbl\", fnname = \"vtbl4_s8\", rettype = \"int8x8_t\", argtypes = \"[int8x8x4_t,int8x8_t]\", vals = [ArrayVal [VectorVal [IntegerVal (-128),IntegerVal (-1),IntegerVal (-128),IntegerVal 0,IntegerVal (-1),IntegerVal (-128),IntegerVal (-128),IntegerVal 127],VectorVal [IntegerVal (-1),IntegerVal (-21),IntegerVal (-36),IntegerVal (-116),IntegerVal 127,IntegerVal (-128),IntegerVal 123,IntegerVal (-1)],VectorVal [IntegerVal 64,IntegerVal 24,IntegerVal 0,IntegerVal (-1),IntegerVal (-128),IntegerVal 127,IntegerVal 127,IntegerVal 119],VectorVal [IntegerVal (-128),IntegerVal 0,IntegerVal (-128),IntegerVal (-1),IntegerVal 0,IntegerVal 127,IntegerVal 127,IntegerVal 0]],VectorVal [IntegerVal (-1),IntegerVal 0,IntegerVal 127,IntegerVal 98,IntegerVal (-1),IntegerVal (-1),IntegerVal 0,IntegerVal 0]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1.val[0] = vcreate_s8(UINT64_C(0x7f8080ff0080ff80));
      arg1.val[1] = vcreate_s8(UINT64_C(0xff7b807f8cdcebff));
      arg1.val[2] = vcreate_s8(UINT64_C(0x777f7f80ff001840));
      arg1.val[3] = vcreate_s8(UINT64_C(0x007f7f00ff800080));
      arg2 = vcreate_s8(UINT64_C(0x0000ffff627f00ff));
      clear_neon_saturated();
      //  Expect: "result" = 8080000000008000
      result = vtbl4_s8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s8(result), 0);
      exp = UINT64_C(0x8080000000008000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_3280() {

{
   {
      poly8x8x4_t arg1;
      uint8x8_t arg2;
      poly8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"tbl\", fnname = \"vtbl4_p8\", rettype = \"poly8x8_t\", argtypes = \"[poly8x8x4_t,uint8x8_t]\", vals = [ArrayVal [VectorVal [PolyVal [1,1,1,1,0,0,0,1],PolyVal [0,0,0,0,0,1,0,1],PolyVal [0,1,1,1,0,0,1,0],PolyVal [1,1,1,1,1,0,0,1],PolyVal [0,0,0,1,1,1,0,0],PolyVal [0,0,0,0,0,0,1,0],PolyVal [1,0,0,0,1,0,0,1],PolyVal [0,1,0,0,1,0,0,0]],VectorVal [PolyVal [0,1,0,0,1,0,1,1],PolyVal [0,0,0,1,1,1,0,1],PolyVal [1,0,0,0,0,0,0,1],PolyVal [0,0,0,0,1,1,1,1],PolyVal [0,0,1,0,0,0,1,1],PolyVal [0,1,1,1,1,1,1,0],PolyVal [0,0,1,1,0,0,0,1],PolyVal [1,1,1,0,1,1,1,0]],VectorVal [PolyVal [0,1,0,0,0,1,1,0],PolyVal [0,0,1,1,0,1,0,1],PolyVal [1,1,0,1,0,1,0,0],PolyVal [0,1,1,0,1,1,1,1],PolyVal [0,1,0,1,1,0,0,1],PolyVal [1,1,1,0,1,1,0,0],PolyVal [0,1,1,0,1,0,1,0],PolyVal [1,0,0,0,0,1,0,0]],VectorVal [PolyVal [0,1,1,0,0,1,0,0],PolyVal [0,0,0,1,1,1,1,0],PolyVal [0,1,1,1,0,0,1,0],PolyVal [0,0,1,1,1,0,0,1],PolyVal [0,0,1,1,1,0,1,0],PolyVal [1,0,1,0,0,1,0,0],PolyVal [1,1,0,0,0,1,1,0],PolyVal [0,1,0,0,0,1,0,1]]],VectorVal [IntegerVal 128,IntegerVal 255,IntegerVal 127,IntegerVal 127,IntegerVal 0,IntegerVal 0,IntegerVal 255,IntegerVal 255]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1.val[0] = vcreate_p8(UINT64_C(0x129140389f4ea08f));
      arg1.val[1] = vcreate_p8(UINT64_C(0x778c7ec4f081b8d2));
      arg1.val[2] = vcreate_p8(UINT64_C(0x2156379af62bac62));
      arg1.val[3] = vcreate_p8(UINT64_C(0xa263255c9c4e7826));
      arg2 = vcreate_u8(UINT64_C(0xffff00007f7fff80));
      clear_neon_saturated();
      //  Expect: "result" = 00008f8f00000000
      result = vtbl4_p8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_p8(result), 0);
      exp = UINT64_C(0x00008f8f00000000);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_3281() {

{
   {
      uint8x8_t arg1;
      uint8x8_t arg2;
      uint8x8_t arg3;
      uint8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"tbx\", fnname = \"vtbx1_u8\", rettype = \"uint8x8_t\", argtypes = \"[uint8x8_t,uint8x8_t,uint8x8_t]\", vals = [VectorVal [IntegerVal 127,IntegerVal 128,IntegerVal 127,IntegerVal 255,IntegerVal 180,IntegerVal 0,IntegerVal 127,IntegerVal 171],VectorVal [IntegerVal 0,IntegerVal 0,IntegerVal 255,IntegerVal 127,IntegerVal 128,IntegerVal 0,IntegerVal 128,IntegerVal 128],VectorVal [IntegerVal 70,IntegerVal 127,IntegerVal 12,IntegerVal 255,IntegerVal 128,IntegerVal 127,IntegerVal 170,IntegerVal 127]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u8(UINT64_C(0xab7f00b4ff7f807f));
      arg2 = vcreate_u8(UINT64_C(0x808000807fff0000));
      arg3 = vcreate_u8(UINT64_C(0x7faa7f80ff0c7f46));
      clear_neon_saturated();
      //  Expect: "result" = ab7f00b4ff7f807f
      result = vtbx1_u8(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u8(result), 0);
      exp = UINT64_C(0xab7f00b4ff7f807f);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_3282() {

{
   {
      int8x8_t arg1;
      int8x8_t arg2;
      int8x8_t arg3;
      int8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"tbx\", fnname = \"vtbx1_s8\", rettype = \"int8x8_t\", argtypes = \"[int8x8_t,int8x8_t,int8x8_t]\", vals = [VectorVal [IntegerVal 0,IntegerVal (-1),IntegerVal 127,IntegerVal 0,IntegerVal 127,IntegerVal (-1),IntegerVal 127,IntegerVal 104],VectorVal [IntegerVal 127,IntegerVal 127,IntegerVal (-90),IntegerVal 127,IntegerVal (-1),IntegerVal 127,IntegerVal (-1),IntegerVal 127],VectorVal [IntegerVal 0,IntegerVal (-25),IntegerVal 127,IntegerVal (-128),IntegerVal 127,IntegerVal (-128),IntegerVal 67,IntegerVal 95]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s8(UINT64_C(0x687fff7f007fff00));
      arg2 = vcreate_s8(UINT64_C(0x7fff7fff7fa67f7f));
      arg3 = vcreate_s8(UINT64_C(0x5f43807f807fe700));
      clear_neon_saturated();
      //  Expect: "result" = 687fff7f007fff7f
      result = vtbx1_s8(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s8(result), 0);
      exp = UINT64_C(0x687fff7f007fff7f);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_3283() {

{
   {
      poly8x8_t arg1;
      poly8x8_t arg2;
      uint8x8_t arg3;
      poly8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"tbx\", fnname = \"vtbx1_p8\", rettype = \"poly8x8_t\", argtypes = \"[poly8x8_t,poly8x8_t,uint8x8_t]\", vals = [VectorVal [PolyVal [1,0,0,0,0,0,0,0],PolyVal [0,1,0,0,1,1,1,0],PolyVal [0,1,1,1,1,0,0,1],PolyVal [0,1,1,1,0,1,0,0],PolyVal [0,1,1,1,1,1,0,0],PolyVal [0,1,1,1,1,1,0,0],PolyVal [0,0,0,0,1,1,1,1],PolyVal [1,1,0,0,0,1,1,0]],VectorVal [PolyVal [1,0,0,1,0,0,1,1],PolyVal [1,1,1,1,0,1,1,1],PolyVal [1,0,0,1,1,1,0,0],PolyVal [0,1,1,1,1,1,0,1],PolyVal [0,0,1,1,0,0,0,0],PolyVal [1,1,0,0,1,1,1,1],PolyVal [0,0,1,1,1,0,1,1],PolyVal [0,0,1,0,1,0,0,0]],VectorVal [IntegerVal 0,IntegerVal 0,IntegerVal 0,IntegerVal 128,IntegerVal 127,IntegerVal 0,IntegerVal 0,IntegerVal 0]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_p8(UINT64_C(0x63f03e3e2e9e7201));
      arg2 = vcreate_p8(UINT64_C(0x14dcf30cbe39efc9));
      arg3 = vcreate_u8(UINT64_C(0x0000007f80000000));
      clear_neon_saturated();
      //  Expect: "result" = c9c9c93e2ec9c9c9
      result = vtbx1_p8(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_p8(result), 0);
      exp = UINT64_C(0xc9c9c93e2ec9c9c9);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_3284() {

{
   {
      uint8x8_t arg1;
      uint8x8x2_t arg2;
      uint8x8_t arg3;
      uint8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"tbx\", fnname = \"vtbx2_u8\", rettype = \"uint8x8_t\", argtypes = \"[uint8x8_t,uint8x8x2_t,uint8x8_t]\", vals = [VectorVal [IntegerVal 73,IntegerVal 231,IntegerVal 63,IntegerVal 100,IntegerVal 255,IntegerVal 128,IntegerVal 253,IntegerVal 127],ArrayVal [VectorVal [IntegerVal 24,IntegerVal 208,IntegerVal 127,IntegerVal 128,IntegerVal 128,IntegerVal 128,IntegerVal 86,IntegerVal 127],VectorVal [IntegerVal 128,IntegerVal 0,IntegerVal 255,IntegerVal 255,IntegerVal 128,IntegerVal 0,IntegerVal 255,IntegerVal 128]],VectorVal [IntegerVal 255,IntegerVal 128,IntegerVal 0,IntegerVal 127,IntegerVal 127,IntegerVal 255,IntegerVal 255,IntegerVal 255]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u8(UINT64_C(0x7ffd80ff643fe749));
      arg2.val[0] = vcreate_u8(UINT64_C(0x7f568080807fd018));
      arg2.val[1] = vcreate_u8(UINT64_C(0x80ff0080ffff0080));
      arg3 = vcreate_u8(UINT64_C(0xffffff7f7f0080ff));
      clear_neon_saturated();
      //  Expect: "result" = 7ffd80ff6418e749
      result = vtbx2_u8(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u8(result), 0);
      exp = UINT64_C(0x7ffd80ff6418e749);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_3285() {

{
   {
      int8x8_t arg1;
      int8x8x2_t arg2;
      int8x8_t arg3;
      int8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"tbx\", fnname = \"vtbx2_s8\", rettype = \"int8x8_t\", argtypes = \"[int8x8_t,int8x8x2_t,int8x8_t]\", vals = [VectorVal [IntegerVal (-1),IntegerVal (-1),IntegerVal 0,IntegerVal (-128),IntegerVal (-66),IntegerVal (-128),IntegerVal 0,IntegerVal 0],ArrayVal [VectorVal [IntegerVal (-128),IntegerVal (-128),IntegerVal 0,IntegerVal (-128),IntegerVal (-1),IntegerVal 127,IntegerVal 127,IntegerVal 0],VectorVal [IntegerVal 0,IntegerVal (-96),IntegerVal (-1),IntegerVal (-128),IntegerVal 0,IntegerVal (-82),IntegerVal 0,IntegerVal 0]],VectorVal [IntegerVal 127,IntegerVal 0,IntegerVal (-128),IntegerVal (-1),IntegerVal 79,IntegerVal (-128),IntegerVal (-1),IntegerVal (-128)]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s8(UINT64_C(0x000080be8000ffff));
      arg2.val[0] = vcreate_s8(UINT64_C(0x007f7fff80008080));
      arg2.val[1] = vcreate_s8(UINT64_C(0x0000ae0080ffa000));
      arg3 = vcreate_s8(UINT64_C(0x80ff804fff80007f));
      clear_neon_saturated();
      //  Expect: "result" = 000080be800080ff
      result = vtbx2_s8(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s8(result), 0);
      exp = UINT64_C(0x000080be800080ff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_3286() {

{
   {
      poly8x8_t arg1;
      poly8x8x2_t arg2;
      uint8x8_t arg3;
      poly8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"tbx\", fnname = \"vtbx2_p8\", rettype = \"poly8x8_t\", argtypes = \"[poly8x8_t,poly8x8x2_t,uint8x8_t]\", vals = [VectorVal [PolyVal [0,0,0,1,0,0,0,0],PolyVal [0,1,1,0,0,1,1,1],PolyVal [1,1,0,1,0,0,1,0],PolyVal [0,1,0,0,1,1,0,0],PolyVal [0,0,1,0,1,1,0,0],PolyVal [0,0,1,0,0,1,0,1],PolyVal [1,0,0,1,0,1,0,0],PolyVal [1,0,1,1,1,0,1,0]],ArrayVal [VectorVal [PolyVal [0,1,0,1,1,0,1,1],PolyVal [1,1,1,1,0,0,0,0],PolyVal [1,1,0,1,1,0,0,0],PolyVal [0,1,1,0,0,1,1,0],PolyVal [0,0,1,1,1,0,0,1],PolyVal [0,1,1,0,0,1,0,1],PolyVal [1,1,0,0,1,0,0,0],PolyVal [1,0,1,0,0,0,1,0]],VectorVal [PolyVal [1,1,1,0,0,1,0,0],PolyVal [1,1,1,1,0,1,0,0],PolyVal [0,0,0,0,0,1,1,0],PolyVal [1,1,0,1,1,0,0,0],PolyVal [0,0,1,0,1,1,0,0],PolyVal [0,1,1,0,0,0,1,0],PolyVal [1,0,1,1,0,0,0,0],PolyVal [1,0,0,0,0,1,1,0]]],VectorVal [IntegerVal 128,IntegerVal 255,IntegerVal 127,IntegerVal 127,IntegerVal 255,IntegerVal 127,IntegerVal 255,IntegerVal 86]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_p8(UINT64_C(0x5d29a434324be608));
      arg2.val[0] = vcreate_p8(UINT64_C(0x4513a69c661b0fda));
      arg2.val[1] = vcreate_p8(UINT64_C(0x610d46341b602f27));
      arg3 = vcreate_u8(UINT64_C(0x56ff7fff7f7fff80));
      clear_neon_saturated();
      //  Expect: "result" = 5d29a434324be608
      result = vtbx2_p8(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_p8(result), 0);
      exp = UINT64_C(0x5d29a434324be608);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_3287() {

{
   {
      uint8x8_t arg1;
      uint8x8x3_t arg2;
      uint8x8_t arg3;
      uint8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"tbx\", fnname = \"vtbx3_u8\", rettype = \"uint8x8_t\", argtypes = \"[uint8x8_t,uint8x8x3_t,uint8x8_t]\", vals = [VectorVal [IntegerVal 255,IntegerVal 128,IntegerVal 128,IntegerVal 0,IntegerVal 255,IntegerVal 128,IntegerVal 127,IntegerVal 0],ArrayVal [VectorVal [IntegerVal 125,IntegerVal 128,IntegerVal 127,IntegerVal 128,IntegerVal 23,IntegerVal 0,IntegerVal 127,IntegerVal 0],VectorVal [IntegerVal 0,IntegerVal 255,IntegerVal 128,IntegerVal 255,IntegerVal 64,IntegerVal 255,IntegerVal 0,IntegerVal 102],VectorVal [IntegerVal 127,IntegerVal 127,IntegerVal 255,IntegerVal 128,IntegerVal 128,IntegerVal 248,IntegerVal 127,IntegerVal 127]],VectorVal [IntegerVal 0,IntegerVal 128,IntegerVal 255,IntegerVal 255,IntegerVal 127,IntegerVal 255,IntegerVal 255,IntegerVal 255]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u8(UINT64_C(0x007f80ff008080ff));
      arg2.val[0] = vcreate_u8(UINT64_C(0x007f0017807f807d));
      arg2.val[1] = vcreate_u8(UINT64_C(0x6600ff40ff80ff00));
      arg2.val[2] = vcreate_u8(UINT64_C(0x7f7ff88080ff7f7f));
      arg3 = vcreate_u8(UINT64_C(0xffffff7fffff8000));
      clear_neon_saturated();
      //  Expect: "result" = 007f80ff0080807d
      result = vtbx3_u8(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u8(result), 0);
      exp = UINT64_C(0x007f80ff0080807d);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_3288() {

{
   {
      int8x8_t arg1;
      int8x8x3_t arg2;
      int8x8_t arg3;
      int8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"tbx\", fnname = \"vtbx3_s8\", rettype = \"int8x8_t\", argtypes = \"[int8x8_t,int8x8x3_t,int8x8_t]\", vals = [VectorVal [IntegerVal (-128),IntegerVal (-1),IntegerVal (-127),IntegerVal 127,IntegerVal 127,IntegerVal 0,IntegerVal 127,IntegerVal (-1)],ArrayVal [VectorVal [IntegerVal (-128),IntegerVal (-128),IntegerVal (-128),IntegerVal 127,IntegerVal 0,IntegerVal 127,IntegerVal (-128),IntegerVal (-128)],VectorVal [IntegerVal 7,IntegerVal 31,IntegerVal 0,IntegerVal (-128),IntegerVal 0,IntegerVal (-50),IntegerVal 0,IntegerVal (-128)],VectorVal [IntegerVal (-1),IntegerVal 127,IntegerVal (-1),IntegerVal 93,IntegerVal (-18),IntegerVal (-128),IntegerVal (-128),IntegerVal (-100)]],VectorVal [IntegerVal 127,IntegerVal 0,IntegerVal (-1),IntegerVal (-1),IntegerVal (-128),IntegerVal (-1),IntegerVal (-106),IntegerVal 127]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s8(UINT64_C(0xff7f007f7f81ff80));
      arg2.val[0] = vcreate_s8(UINT64_C(0x80807f007f808080));
      arg2.val[1] = vcreate_s8(UINT64_C(0x8000ce0080001f07));
      arg2.val[2] = vcreate_s8(UINT64_C(0x9c8080ee5dff7fff));
      arg3 = vcreate_s8(UINT64_C(0x7f96ff80ffff007f));
      clear_neon_saturated();
      //  Expect: "result" = ff7f007f7f818080
      result = vtbx3_s8(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s8(result), 0);
      exp = UINT64_C(0xff7f007f7f818080);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_3289() {

{
   {
      poly8x8_t arg1;
      poly8x8x3_t arg2;
      uint8x8_t arg3;
      poly8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"tbx\", fnname = \"vtbx3_p8\", rettype = \"poly8x8_t\", argtypes = \"[poly8x8_t,poly8x8x3_t,uint8x8_t]\", vals = [VectorVal [PolyVal [0,1,1,0,0,1,1,0],PolyVal [1,1,0,0,0,1,1,1],PolyVal [0,0,0,0,0,1,0,0],PolyVal [0,0,0,1,1,1,0,0],PolyVal [0,0,0,0,0,0,1,0],PolyVal [0,1,1,0,1,0,0,0],PolyVal [0,0,0,1,1,0,0,1],PolyVal [1,1,1,1,1,1,0,1]],ArrayVal [VectorVal [PolyVal [0,0,1,1,1,1,1,1],PolyVal [1,0,0,0,1,0,1,1],PolyVal [0,0,0,0,1,0,0,0],PolyVal [0,1,0,1,0,0,0,1],PolyVal [1,1,0,0,0,1,1,0],PolyVal [0,0,1,1,0,0,1,1],PolyVal [0,1,0,1,1,1,0,1],PolyVal [1,1,0,0,0,0,0,1]],VectorVal [PolyVal [0,1,1,0,1,0,1,1],PolyVal [1,0,0,0,0,1,0,1],PolyVal [0,1,1,1,0,1,1,1],PolyVal [0,0,1,0,1,1,1,0],PolyVal [1,0,0,0,1,1,1,0],PolyVal [1,1,0,0,0,1,1,1],PolyVal [1,0,0,0,0,1,0,0],PolyVal [0,1,0,0,1,1,0,0]],VectorVal [PolyVal [0,0,0,0,0,0,1,0],PolyVal [0,0,0,1,0,0,0,1],PolyVal [0,1,0,1,1,1,1,0],PolyVal [0,0,1,1,0,0,0,0],PolyVal [1,1,1,0,1,0,1,0],PolyVal [1,1,0,1,0,0,0,1],PolyVal [1,0,1,0,1,1,0,0],PolyVal [1,0,1,0,1,0,1,0]]],VectorVal [IntegerVal 128,IntegerVal 255,IntegerVal 88,IntegerVal 255,IntegerVal 128,IntegerVal 189,IntegerVal 0,IntegerVal 0]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_p8(UINT64_C(0xbf9816403820e366));
      arg2.val[0] = vcreate_p8(UINT64_C(0x83bacc638a10d1fc));
      arg2.val[1] = vcreate_p8(UINT64_C(0x3221e37174eea1d6));
      arg2.val[2] = vcreate_p8(UINT64_C(0x55358b570c7a8840));
      arg3 = vcreate_u8(UINT64_C(0x0000bd80ff58ff80));
      clear_neon_saturated();
      //  Expect: "result" = fcfc16403820e366
      result = vtbx3_p8(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_p8(result), 0);
      exp = UINT64_C(0xfcfc16403820e366);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_3290() {

{
   {
      uint8x8_t arg1;
      uint8x8x4_t arg2;
      uint8x8_t arg3;
      uint8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"tbx\", fnname = \"vtbx4_u8\", rettype = \"uint8x8_t\", argtypes = \"[uint8x8_t,uint8x8x4_t,uint8x8_t]\", vals = [VectorVal [IntegerVal 255,IntegerVal 127,IntegerVal 128,IntegerVal 123,IntegerVal 128,IntegerVal 0,IntegerVal 255,IntegerVal 255],ArrayVal [VectorVal [IntegerVal 0,IntegerVal 127,IntegerVal 194,IntegerVal 0,IntegerVal 128,IntegerVal 128,IntegerVal 86,IntegerVal 0],VectorVal [IntegerVal 131,IntegerVal 128,IntegerVal 128,IntegerVal 255,IntegerVal 0,IntegerVal 255,IntegerVal 232,IntegerVal 127],VectorVal [IntegerVal 128,IntegerVal 255,IntegerVal 104,IntegerVal 199,IntegerVal 128,IntegerVal 255,IntegerVal 0,IntegerVal 71],VectorVal [IntegerVal 127,IntegerVal 0,IntegerVal 0,IntegerVal 255,IntegerVal 0,IntegerVal 255,IntegerVal 128,IntegerVal 127]],VectorVal [IntegerVal 255,IntegerVal 255,IntegerVal 128,IntegerVal 188,IntegerVal 255,IntegerVal 127,IntegerVal 255,IntegerVal 127]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_u8(UINT64_C(0xffff00807b807fff));
      arg2.val[0] = vcreate_u8(UINT64_C(0x0056808000c27f00));
      arg2.val[1] = vcreate_u8(UINT64_C(0x7fe8ff00ff808083));
      arg2.val[2] = vcreate_u8(UINT64_C(0x4700ff80c768ff80));
      arg2.val[3] = vcreate_u8(UINT64_C(0x7f80ff00ff00007f));
      arg3 = vcreate_u8(UINT64_C(0x7fff7fffbc80ffff));
      clear_neon_saturated();
      //  Expect: "result" = ffff00807b807fff
      result = vtbx4_u8(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_u8(result), 0);
      exp = UINT64_C(0xffff00807b807fff);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_3291() {

{
   {
      int8x8_t arg1;
      int8x8x4_t arg2;
      int8x8_t arg3;
      int8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"tbx\", fnname = \"vtbx4_s8\", rettype = \"int8x8_t\", argtypes = \"[int8x8_t,int8x8x4_t,int8x8_t]\", vals = [VectorVal [IntegerVal 0,IntegerVal (-107),IntegerVal (-128),IntegerVal (-128),IntegerVal (-128),IntegerVal 127,IntegerVal (-1),IntegerVal 0],ArrayVal [VectorVal [IntegerVal (-128),IntegerVal (-94),IntegerVal 0,IntegerVal (-1),IntegerVal (-128),IntegerVal 0,IntegerVal (-98),IntegerVal 0],VectorVal [IntegerVal (-82),IntegerVal 127,IntegerVal (-128),IntegerVal (-1),IntegerVal 0,IntegerVal (-102),IntegerVal (-90),IntegerVal (-1)],VectorVal [IntegerVal 127,IntegerVal (-92),IntegerVal (-128),IntegerVal 0,IntegerVal 1,IntegerVal 0,IntegerVal (-128),IntegerVal 127],VectorVal [IntegerVal 0,IntegerVal (-1),IntegerVal (-128),IntegerVal 93,IntegerVal (-128),IntegerVal 0,IntegerVal 0,IntegerVal (-1)]],VectorVal [IntegerVal (-128),IntegerVal 127,IntegerVal 0,IntegerVal (-3),IntegerVal (-1),IntegerVal 127,IntegerVal 127,IntegerVal (-1)]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_s8(UINT64_C(0x00ff7f8080809500));
      arg2.val[0] = vcreate_s8(UINT64_C(0x009e0080ff00a280));
      arg2.val[1] = vcreate_s8(UINT64_C(0xffa69a00ff807fae));
      arg2.val[2] = vcreate_s8(UINT64_C(0x7f8000010080a47f));
      arg2.val[3] = vcreate_s8(UINT64_C(0xff0000805d80ff00));
      arg3 = vcreate_s8(UINT64_C(0xff7f7ffffd007f80));
      clear_neon_saturated();
      //  Expect: "result" = 00ff7f8080809500
      result = vtbx4_s8(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_s8(result), 0);
      exp = UINT64_C(0x00ff7f8080809500);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_3292() {

{
   {
      poly8x8_t arg1;
      poly8x8x4_t arg2;
      uint8x8_t arg3;
      poly8x8_t result;
      char* str1 = "ReproInfo2 {semantics = \"tbx\", fnname = \"vtbx4_p8\", rettype = \"poly8x8_t\", argtypes = \"[poly8x8_t,poly8x8x4_t,uint8x8_t]\", vals = [VectorVal [PolyVal [1,0,1,0,1,1,0,1],PolyVal [0,0,1,0,1,1,0,0],PolyVal [0,1,0,1,0,1,1,0],PolyVal [1,1,1,1,0,0,0,0],PolyVal [1,0,1,0,1,0,0,1],PolyVal [0,0,1,1,1,0,0,0],PolyVal [0,0,1,0,0,0,0,1],PolyVal [0,1,0,1,0,1,1,0]],ArrayVal [VectorVal [PolyVal [1,1,1,0,1,0,0,1],PolyVal [0,1,0,0,1,0,1,1],PolyVal [0,0,0,0,1,0,0,0],PolyVal [0,0,1,0,0,1,1,0],PolyVal [0,0,1,0,1,0,1,0],PolyVal [0,1,1,0,1,1,1,1],PolyVal [1,1,1,0,1,0,1,0],PolyVal [1,1,0,1,0,1,1,0]],VectorVal [PolyVal [0,1,1,1,0,0,1,0],PolyVal [1,1,1,0,1,0,1,1],PolyVal [0,0,1,1,1,0,0,1],PolyVal [1,1,1,0,1,0,1,1],PolyVal [1,0,0,1,1,0,0,1],PolyVal [1,1,1,1,0,0,0,1],PolyVal [1,0,1,1,1,0,0,1],PolyVal [0,1,1,1,0,1,0,1]],VectorVal [PolyVal [1,0,0,0,1,1,0,1],PolyVal [1,1,1,1,1,0,0,1],PolyVal [0,1,0,0,1,0,1,1],PolyVal [1,0,1,0,0,0,1,1],PolyVal [1,0,1,1,0,1,1,1],PolyVal [1,1,1,0,1,1,1,0],PolyVal [1,1,1,0,1,1,0,0],PolyVal [0,1,0,1,0,0,1,0]],VectorVal [PolyVal [0,0,0,1,1,1,1,0],PolyVal [1,1,1,1,1,0,1,0],PolyVal [0,0,0,1,1,0,0,1],PolyVal [0,1,0,1,0,1,0,0],PolyVal [1,0,1,1,1,1,0,1],PolyVal [0,0,0,1,1,0,0,0],PolyVal [1,1,1,0,1,1,1,1],PolyVal [0,0,0,0,0,1,1,0]]],VectorVal [IntegerVal 255,IntegerVal 128,IntegerVal 255,IntegerVal 255,IntegerVal 127,IntegerVal 127,IntegerVal 128,IntegerVal 127]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcreate_p8(UINT64_C(0x6a841c950f6a34b5));
      arg2.val[0] = vcreate_p8(UINT64_C(0x6b57f6546410d297));
      arg2.val[1] = vcreate_p8(UINT64_C(0xae9d8f99d79cd74e));
      arg2.val[2] = vcreate_p8(UINT64_C(0x4a3777edc5d29fb1));
      arg2.val[3] = vcreate_p8(UINT64_C(0x60f718bd2a985f78));
      arg3 = vcreate_u8(UINT64_C(0x7f807f7fffff80ff));
      clear_neon_saturated();
      //  Expect: "result" = 6a841c950f6a34b5
      result = vtbx4_p8(arg1, arg2, arg3);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = vget_lane_u64(vreinterpret_u64_p8(result), 0);
      exp = UINT64_C(0x6a841c950f6a34b5);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_3293() {

{
   {
      int8x8_t arg1;
      int8x8_t arg2;
      int8x8x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"trn\", fnname = \"vtrn_s8\", rettype = \"int8x8x2_t\", argtypes = \"[int8x8_t,int8x8_t]\", vals = [VectorVal [IntegerVal (-128),IntegerVal 127,IntegerVal 60,IntegerVal (-128),IntegerVal (-1),IntegerVal 50,IntegerVal 0,IntegerVal (-110)],VectorVal [IntegerVal (-128),IntegerVal 0,IntegerVal 127,IntegerVal 0,IntegerVal 127,IntegerVal 127,IntegerVal 0,IntegerVal 0]], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_s8(UINT64_C(0x920032ff803c7f80));
      arg2 = vcreate_s8(UINT64_C(0x00007f7f007f0080));
      clear_neon_saturated();
      //  Expect: "result" = 00927f320080007f00007fff7f3c8080
      result = vtrn_s8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_s8(result.val[0]), 0);
         exp = UINT64_C(0x00007fff7f3c8080);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_s8(result.val[1]), 0);
         exp = UINT64_C(0x00927f320080007f);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_3294() {

{
   {
      int16x4_t arg1;
      int16x4_t arg2;
      int16x4x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"trn\", fnname = \"vtrn_s16\", rettype = \"int16x4x2_t\", argtypes = \"[int16x4_t,int16x4_t]\", vals = [VectorVal [IntegerVal (-32768),IntegerVal 32767,IntegerVal (-22688),IntegerVal (-1)],VectorVal [IntegerVal (-1),IntegerVal (-1),IntegerVal 32767,IntegerVal 2350]], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_s16(UINT64_C(0xffffa7607fff8000));
      arg2 = vcreate_s16(UINT64_C(0x092e7fffffffffff));
      clear_neon_saturated();
      //  Expect: "result" = 092effffffff7fff7fffa760ffff8000
      result = vtrn_s16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_s16(result.val[0]), 0);
         exp = UINT64_C(0x7fffa760ffff8000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_s16(result.val[1]), 0);
         exp = UINT64_C(0x092effffffff7fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_3295() {

{
   {
      int32x2_t arg1;
      int32x2_t arg2;
      int32x2x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"trn\", fnname = \"vtrn_s32\", rettype = \"int32x2x2_t\", argtypes = \"[int32x2_t,int32x2_t]\", vals = [VectorVal [IntegerVal 2147473931,IntegerVal 32768],VectorVal [IntegerVal (-2147450880),IntegerVal 32768]], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_s32(UINT64_C(0x000080007fffda0b));
      arg2 = vcreate_s32(UINT64_C(0x0000800080008000));
      clear_neon_saturated();
      //  Expect: "result" = 0000800000008000800080007fffda0b
      result = vtrn_s32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_s32(result.val[0]), 0);
         exp = UINT64_C(0x800080007fffda0b);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_s32(result.val[1]), 0);
         exp = UINT64_C(0x0000800000008000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_3296() {

{
   {
      uint8x8_t arg1;
      uint8x8_t arg2;
      uint8x8x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"trn\", fnname = \"vtrn_u8\", rettype = \"uint8x8x2_t\", argtypes = \"[uint8x8_t,uint8x8_t]\", vals = [VectorVal [IntegerVal 0,IntegerVal 196,IntegerVal 127,IntegerVal 0,IntegerVal 190,IntegerVal 128,IntegerVal 0,IntegerVal 128],VectorVal [IntegerVal 27,IntegerVal 14,IntegerVal 82,IntegerVal 128,IntegerVal 0,IntegerVal 127,IntegerVal 170,IntegerVal 149]], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_u8(UINT64_C(0x800080be007fc400));
      arg2 = vcreate_u8(UINT64_C(0x95aa7f0080520e1b));
      clear_neon_saturated();
      //  Expect: "result" = 95807f8080000ec4aa0000be527f1b00
      result = vtrn_u8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_u8(result.val[0]), 0);
         exp = UINT64_C(0xaa0000be527f1b00);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_u8(result.val[1]), 0);
         exp = UINT64_C(0x95807f8080000ec4);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_3297() {

{
   {
      uint16x4_t arg1;
      uint16x4_t arg2;
      uint16x4x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"trn\", fnname = \"vtrn_u16\", rettype = \"uint16x4x2_t\", argtypes = \"[uint16x4_t,uint16x4_t]\", vals = [VectorVal [IntegerVal 60013,IntegerVal 34121,IntegerVal 32767,IntegerVal 65535],VectorVal [IntegerVal 32767,IntegerVal 40393,IntegerVal 32768,IntegerVal 65535]], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_u16(UINT64_C(0xffff7fff8549ea6d));
      arg2 = vcreate_u16(UINT64_C(0xffff80009dc97fff));
      clear_neon_saturated();
      //  Expect: "result" = ffffffff9dc9854980007fff7fffea6d
      result = vtrn_u16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_u16(result.val[0]), 0);
         exp = UINT64_C(0x80007fff7fffea6d);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_u16(result.val[1]), 0);
         exp = UINT64_C(0xffffffff9dc98549);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_3298() {

{
   {
      uint32x2_t arg1;
      uint32x2_t arg2;
      uint32x2x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"trn\", fnname = \"vtrn_u32\", rettype = \"uint32x2x2_t\", argtypes = \"[uint32x2_t,uint32x2_t]\", vals = [VectorVal [IntegerVal 32767,IntegerVal 2147448313],VectorVal [IntegerVal 3086843903,IntegerVal 2147483648]], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_u32(UINT64_C(0x7fff75f900007fff));
      arg2 = vcreate_u32(UINT64_C(0x80000000b7fd7fff));
      clear_neon_saturated();
      //  Expect: "result" = 800000007fff75f9b7fd7fff00007fff
      result = vtrn_u32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_u32(result.val[0]), 0);
         exp = UINT64_C(0xb7fd7fff00007fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_u32(result.val[1]), 0);
         exp = UINT64_C(0x800000007fff75f9);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_3299() {

{
   {
      float32x2_t arg1;
      float32x2_t arg2;
      float32x2x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"trn\", fnname = \"vtrn_f32\", rettype = \"float32x2x2_t\", argtypes = \"[float32x2_t,float32x2_t]\", vals = [VectorVal [FloatVal 0.9558741450309753,FloatVal 0.7030755281448364],VectorVal [FloatVal 1.192396879196167e-2,FloatVal 0.5608712434768677]], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_f32(UINT64_C(0x3f33fcc23f74b42b));
      arg2 = vcreate_f32(UINT64_C(0x3f0f95423c435cc0));
      clear_neon_saturated();
      //  Expect: "result" = 3f0f95423f33fcc23c435cc03f74b42b
      result = vtrn_f32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result.val[0], 0);
         exp = ((float32_t) 0.9558741450309753);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 0 ",
                      exp,
                      got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result.val[0], 1);
         exp = ((float32_t) 1.192396879196167e-2);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 1 ",
                      exp,
                      got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result.val[1], 0);
         exp = ((float32_t) 0.7030755281448364);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 0 ",
                      exp,
                      got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result.val[1], 1);
         exp = ((float32_t) 0.5608712434768677);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 1 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_3300() {

{
   {
      poly8x8_t arg1;
      poly8x8_t arg2;
      poly8x8x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"trn\", fnname = \"vtrn_p8\", rettype = \"poly8x8x2_t\", argtypes = \"[poly8x8_t,poly8x8_t]\", vals = [VectorVal [PolyVal [1,1,0,0,0,0,1,1],PolyVal [1,1,0,1,0,0,1,1],PolyVal [1,1,0,1,1,0,0,0],PolyVal [1,0,0,1,0,1,0,0],PolyVal [0,0,0,1,1,0,0,0],PolyVal [1,1,0,1,0,1,1,0],PolyVal [0,1,0,0,0,1,0,0],PolyVal [1,1,0,1,1,1,1,1]],VectorVal [PolyVal [0,0,1,0,0,1,1,1],PolyVal [1,0,1,1,0,0,1,0],PolyVal [0,1,1,1,1,0,1,0],PolyVal [0,1,1,1,1,0,1,0],PolyVal [1,1,0,1,1,0,1,1],PolyVal [1,0,1,0,1,0,1,1],PolyVal [0,1,0,0,0,0,1,1],PolyVal [0,1,1,1,0,1,0,0]]], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_p8(UINT64_C(0xfb226b18291bcbc3));
      arg2 = vcreate_p8(UINT64_C(0x2ec2d5db5e5e4de4));
      clear_neon_saturated();
      //  Expect: "result" = 2efbd56b5e294dcbc222db185e1be4c3
      result = vtrn_p8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_p8(result.val[0]), 0);
         exp = UINT64_C(0xc222db185e1be4c3);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_p8(result.val[1]), 0);
         exp = UINT64_C(0x2efbd56b5e294dcb);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_3301() {

{
   {
      poly16x4_t arg1;
      poly16x4_t arg2;
      poly16x4x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"trn\", fnname = \"vtrn_p16\", rettype = \"poly16x4x2_t\", argtypes = \"[poly16x4_t,poly16x4_t]\", vals = [VectorVal [PolyVal [0,1,0,1,0,1,1,0,1,0,1,1,0,1,1,1],PolyVal [1,0,1,1,1,0,1,1,1,1,1,1,1,1,0,1],PolyVal [0,0,0,0,0,0,0,1,0,1,1,0,1,0,0,0],PolyVal [0,1,1,1,0,1,1,0,0,0,0,0,1,1,1,1]],VectorVal [PolyVal [0,0,0,1,1,1,1,0,0,1,0,1,0,1,1,1],PolyVal [1,1,1,0,0,0,0,1,1,1,0,0,1,1,1,1],PolyVal [0,0,1,1,1,0,0,1,1,0,0,0,0,1,0,1],PolyVal [1,1,1,0,1,0,1,0,1,1,1,0,0,0,0,1]]], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_p16(UINT64_C(0xf06e1680bfdded6a));
      arg2 = vcreate_p16(UINT64_C(0x8757a19cf387ea78));
      clear_neon_saturated();
      //  Expect: "result" = 8757f06ef387bfdda19c1680ea78ed6a
      result = vtrn_p16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_p16(result.val[0]), 0);
         exp = UINT64_C(0xa19c1680ea78ed6a);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_p16(result.val[1]), 0);
         exp = UINT64_C(0x8757f06ef387bfdd);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_3302() {

{
   {
      int8x16_t arg1;
      int8x16_t arg2;
      int8x16x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"trn\", fnname = \"vtrnq_s8\", rettype = \"int8x16x2_t\", argtypes = \"[int8x16_t,int8x16_t]\", vals = [VectorVal [IntegerVal 0,IntegerVal 0,IntegerVal 0,IntegerVal (-39),IntegerVal 62,IntegerVal (-128),IntegerVal 0,IntegerVal (-26),IntegerVal 0,IntegerVal (-1),IntegerVal (-1),IntegerVal 0,IntegerVal (-1),IntegerVal (-1),IntegerVal 127,IntegerVal 127],VectorVal [IntegerVal (-128),IntegerVal (-101),IntegerVal (-1),IntegerVal (-84),IntegerVal 127,IntegerVal (-76),IntegerVal 127,IntegerVal 0,IntegerVal (-128),IntegerVal 76,IntegerVal 127,IntegerVal 127,IntegerVal 123,IntegerVal (-1),IntegerVal (-3),IntegerVal (-1)]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s8(vcreate_s8(UINT64_C(0xe600803ed9000000)),
                         vcreate_s8(UINT64_C(0x7f7fffff00ffff00)));
      arg2 = vcombine_s8(vcreate_s8(UINT64_C(0x007fb47facff9b80)),
                         vcreate_s8(UINT64_C(0xfffdff7b7f7f4c80)));
      clear_neon_saturated();
      //  Expect: "result" = ff7fffff7f004cff00e6b480acd99b00fd7f7bff7fff80007f007f3eff008000
      result = vtrnq_s8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result.val[0]), 0);
         exp = UINT64_C(0x7f007f3eff008000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result.val[0]), 1);
         exp = UINT64_C(0xfd7f7bff7fff8000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result.val[1]), 0);
         exp = UINT64_C(0x00e6b480acd99b00);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result.val[1]), 1);
         exp = UINT64_C(0xff7fffff7f004cff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_3303() {

{
   {
      int16x8_t arg1;
      int16x8_t arg2;
      int16x8x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"trn\", fnname = \"vtrnq_s16\", rettype = \"int16x8x2_t\", argtypes = \"[int16x8_t,int16x8_t]\", vals = [VectorVal [IntegerVal (-1),IntegerVal (-1),IntegerVal 32767,IntegerVal (-32768),IntegerVal 19510,IntegerVal 0,IntegerVal (-32768),IntegerVal (-8476)],VectorVal [IntegerVal 0,IntegerVal 0,IntegerVal 0,IntegerVal 32767,IntegerVal 32767,IntegerVal (-1),IntegerVal 17777,IntegerVal (-1)]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s16(vcreate_s16(UINT64_C(0x80007fffffffffff)),
                          vcreate_s16(UINT64_C(0xdee4800000004c36)));
      arg2 = vcombine_s16(vcreate_s16(UINT64_C(0x7fff000000000000)),
                          vcreate_s16(UINT64_C(0xffff4571ffff7fff)));
      clear_neon_saturated();
      //  Expect: "result" = ffffdee4ffff00007fff80000000ffff457180007fff4c3600007fff0000ffff
      result = vtrnq_s16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result.val[0]), 0);
         exp = UINT64_C(0x00007fff0000ffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result.val[0]), 1);
         exp = UINT64_C(0x457180007fff4c36);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result.val[1]), 0);
         exp = UINT64_C(0x7fff80000000ffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result.val[1]), 1);
         exp = UINT64_C(0xffffdee4ffff0000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_3304() {

{
   {
      int32x4_t arg1;
      int32x4_t arg2;
      int32x4x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"trn\", fnname = \"vtrnq_s32\", rettype = \"int32x4x2_t\", argtypes = \"[int32x4_t,int32x4_t]\", vals = [VectorVal [IntegerVal 1024557055,IntegerVal 2147483647,IntegerVal (-2147464674),IntegerVal 0],VectorVal [IntegerVal 1829142527,IntegerVal 32768,IntegerVal (-1506803713),IntegerVal (-2147461217)]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s32(vcreate_s32(UINT64_C(0x7fffffff3d117fff)),
                          vcreate_s32(UINT64_C(0x0000000080004a1e)));
      arg2 = vcombine_s32(vcreate_s32(UINT64_C(0x000080006d067fff)),
                          vcreate_s32(UINT64_C(0x8000579fa62fffff)));
      clear_neon_saturated();
      //  Expect: "result" = 8000579f00000000000080007fffffffa62fffff80004a1e6d067fff3d117fff
      result = vtrnq_s32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result.val[0]), 0);
         exp = UINT64_C(0x6d067fff3d117fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result.val[0]), 1);
         exp = UINT64_C(0xa62fffff80004a1e);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result.val[1]), 0);
         exp = UINT64_C(0x000080007fffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result.val[1]), 1);
         exp = UINT64_C(0x8000579f00000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_3305() {

{
   {
      uint8x16_t arg1;
      uint8x16_t arg2;
      uint8x16x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"trn\", fnname = \"vtrnq_u8\", rettype = \"uint8x16x2_t\", argtypes = \"[uint8x16_t,uint8x16_t]\", vals = [VectorVal [IntegerVal 255,IntegerVal 0,IntegerVal 127,IntegerVal 255,IntegerVal 128,IntegerVal 128,IntegerVal 127,IntegerVal 128,IntegerVal 255,IntegerVal 128,IntegerVal 0,IntegerVal 81,IntegerVal 0,IntegerVal 127,IntegerVal 255,IntegerVal 0],VectorVal [IntegerVal 255,IntegerVal 67,IntegerVal 127,IntegerVal 127,IntegerVal 255,IntegerVal 127,IntegerVal 255,IntegerVal 0,IntegerVal 121,IntegerVal 127,IntegerVal 0,IntegerVal 255,IntegerVal 128,IntegerVal 80,IntegerVal 127,IntegerVal 36]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u8(vcreate_u8(UINT64_C(0x807f8080ff7f00ff)),
                         vcreate_u8(UINT64_C(0x00ff7f00510080ff)));
      arg2 = vcombine_u8(vcreate_u8(UINT64_C(0x00ff7fff7f7f43ff)),
                         vcreate_u8(UINT64_C(0x247f5080ff007f79)));
      clear_neon_saturated();
      //  Expect: "result" = 2400507fff517f8000807f807fff43007fff8000000079ffff7fff807f7fffff
      result = vtrnq_u8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result.val[0]), 0);
         exp = UINT64_C(0xff7fff807f7fffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result.val[0]), 1);
         exp = UINT64_C(0x7fff8000000079ff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result.val[1]), 0);
         exp = UINT64_C(0x00807f807fff4300);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result.val[1]), 1);
         exp = UINT64_C(0x2400507fff517f80);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_3306() {

{
   {
      uint16x8_t arg1;
      uint16x8_t arg2;
      uint16x8x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"trn\", fnname = \"vtrnq_u16\", rettype = \"uint16x8x2_t\", argtypes = \"[uint16x8_t,uint16x8_t]\", vals = [VectorVal [IntegerVal 53682,IntegerVal 32767,IntegerVal 5370,IntegerVal 63615,IntegerVal 0,IntegerVal 32767,IntegerVal 32768,IntegerVal 65535],VectorVal [IntegerVal 31300,IntegerVal 29348,IntegerVal 32767,IntegerVal 0,IntegerVal 32767,IntegerVal 32768,IntegerVal 32767,IntegerVal 31046]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u16(vcreate_u16(UINT64_C(0xf87f14fa7fffd1b2)),
                          vcreate_u16(UINT64_C(0xffff80007fff0000)));
      arg2 = vcombine_u16(vcreate_u16(UINT64_C(0x00007fff72a47a44)),
                          vcreate_u16(UINT64_C(0x79467fff80007fff)));
      clear_neon_saturated();
      //  Expect: "result" = 7946ffff80007fff0000f87f72a47fff7fff80007fff00007fff14fa7a44d1b2
      result = vtrnq_u16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result.val[0]), 0);
         exp = UINT64_C(0x7fff14fa7a44d1b2);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result.val[0]), 1);
         exp = UINT64_C(0x7fff80007fff0000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result.val[1]), 0);
         exp = UINT64_C(0x0000f87f72a47fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result.val[1]), 1);
         exp = UINT64_C(0x7946ffff80007fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_3307() {

{
   {
      uint32x4_t arg1;
      uint32x4_t arg2;
      uint32x4x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"trn\", fnname = \"vtrnq_u32\", rettype = \"uint32x4x2_t\", argtypes = \"[uint32x4_t,uint32x4_t]\", vals = [VectorVal [IntegerVal 2198994944,IntegerVal 4491,IntegerVal 32767,IntegerVal 4294934527],VectorVal [IntegerVal 6593,IntegerVal 4294934528,IntegerVal 32767,IntegerVal 4294927834]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u32(vcreate_u32(UINT64_C(0x0000118b83120000)),
                          vcreate_u32(UINT64_C(0xffff7fff00007fff)));
      arg2 = vcombine_u32(vcreate_u32(UINT64_C(0xffff8000000019c1)),
                          vcreate_u32(UINT64_C(0xffff65da00007fff)));
      clear_neon_saturated();
      //  Expect: "result" = ffff65daffff7fffffff80000000118b00007fff00007fff000019c183120000
      result = vtrnq_u32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result.val[0]), 0);
         exp = UINT64_C(0x000019c183120000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result.val[0]), 1);
         exp = UINT64_C(0x00007fff00007fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result.val[1]), 0);
         exp = UINT64_C(0xffff80000000118b);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result.val[1]), 1);
         exp = UINT64_C(0xffff65daffff7fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_3308() {

{
   {
      float32x4_t arg1;
      float32x4_t arg2;
      float32x4x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"trn\", fnname = \"vtrnq_f32\", rettype = \"float32x4x2_t\", argtypes = \"[float32x4_t,float32x4_t]\", vals = [VectorVal [FloatVal 0.19854849576950073,FloatVal 9.443718194961548e-2,FloatVal 0.646360456943512,FloatVal 0.44472289085388184],VectorVal [FloatVal 0.650431752204895,FloatVal 0.8432634472846985,FloatVal 8.447355031967163e-2,FloatVal 0.5038052797317505]], start_saturated = True}";
      int reported = 0;
      arg1 = vcombine_f32(vcreate_f32(UINT64_C(0x3dc168483e4b504c)),
                          vcreate_f32(UINT64_C(0x3ee3b2b83f2577e1)));
      arg2 = vcombine_f32(vcreate_f32(UINT64_C(0x3f57e01d3f2682b2)),
                          vcreate_f32(UINT64_C(0x3f00f9623dad0078)));
      set_neon_saturated();
      //  Expect: "result" = 3f00f9623ee3b2b83f57e01d3dc168483dad00783f2577e13f2682b23e4b504c
      result = vtrnq_f32(arg1, arg2);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result.val[0], 0);
         exp = ((float32_t) 0.19854849576950073);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 0 ",
                      exp,
                      got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result.val[0], 1);
         exp = ((float32_t) 0.650431752204895);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 1 ",
                      exp,
                      got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result.val[0], 2);
         exp = ((float32_t) 0.646360456943512);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 2 ",
                      exp,
                      got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result.val[0], 3);
         exp = ((float32_t) 8.447355031967163e-2);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 3 ",
                      exp,
                      got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result.val[1], 0);
         exp = ((float32_t) 9.443718194961548e-2);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 0 ",
                      exp,
                      got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result.val[1], 1);
         exp = ((float32_t) 0.8432634472846985);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 1 ",
                      exp,
                      got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result.val[1], 2);
         exp = ((float32_t) 0.44472289085388184);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 2 ",
                      exp,
                      got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result.val[1], 3);
         exp = ((float32_t) 0.5038052797317505);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 3 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_3309() {

{
   {
      poly8x16_t arg1;
      poly8x16_t arg2;
      poly8x16x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"trn\", fnname = \"vtrnq_p8\", rettype = \"poly8x16x2_t\", argtypes = \"[poly8x16_t,poly8x16_t]\", vals = [VectorVal [PolyVal [0,1,0,0,1,1,0,1],PolyVal [0,0,1,1,0,1,0,1],PolyVal [1,0,1,0,0,0,0,0],PolyVal [0,0,0,1,1,0,0,1],PolyVal [0,0,1,1,1,1,1,1],PolyVal [0,0,0,1,1,0,1,0],PolyVal [1,1,1,1,0,0,1,0],PolyVal [0,1,0,1,1,1,1,1],PolyVal [1,1,0,1,0,0,1,0],PolyVal [0,1,1,0,0,1,1,1],PolyVal [0,1,0,1,0,0,1,0],PolyVal [0,1,0,0,0,0,0,1],PolyVal [0,1,0,1,1,0,1,0],PolyVal [0,1,0,0,0,1,0,1],PolyVal [0,1,0,1,0,1,1,1],PolyVal [1,0,1,0,0,1,1,0]],VectorVal [PolyVal [1,1,0,1,0,1,0,1],PolyVal [1,0,1,1,1,0,0,0],PolyVal [0,1,0,1,0,0,0,0],PolyVal [1,0,0,0,0,1,0,0],PolyVal [0,0,0,1,0,0,0,0],PolyVal [0,0,0,0,0,0,1,1],PolyVal [0,1,1,0,1,0,1,0],PolyVal [0,1,1,0,1,0,0,1],PolyVal [0,0,1,0,0,1,0,1],PolyVal [1,1,1,0,0,1,1,0],PolyVal [0,0,0,0,1,1,0,1],PolyVal [1,1,1,1,0,1,1,0],PolyVal [1,0,0,1,0,1,0,0],PolyVal [1,0,0,0,0,1,0,0],PolyVal [0,0,1,1,0,0,1,0],PolyVal [0,0,1,1,1,1,1,1]]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_p8(vcreate_p8(UINT64_C(0xfa4f58fc9805acb2)),
                         vcreate_p8(UINT64_C(0x65eaa25a824ae64b)));
      arg2 = vcombine_p8(vcreate_p8(UINT64_C(0x9656c008210a1dab)),
                         vcreate_p8(UINT64_C(0xfc4c21296fb067a4)));
      clear_neon_saturated();
      //  Expect: "result" = fc6521a26f8267e696fac05821981dac4cea295ab04aa44b564f08fc0a05abb2
      result = vtrnq_p8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p8(result.val[0]), 0);
         exp = UINT64_C(0x564f08fc0a05abb2);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p8(result.val[0]), 1);
         exp = UINT64_C(0x4cea295ab04aa44b);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p8(result.val[1]), 0);
         exp = UINT64_C(0x96fac05821981dac);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p8(result.val[1]), 1);
         exp = UINT64_C(0xfc6521a26f8267e6);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_3310() {

{
   {
      poly16x8_t arg1;
      poly16x8_t arg2;
      poly16x8x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"trn\", fnname = \"vtrnq_p16\", rettype = \"poly16x8x2_t\", argtypes = \"[poly16x8_t,poly16x8_t]\", vals = [VectorVal [PolyVal [0,0,0,0,1,0,1,1,0,0,0,0,0,0,1,0],PolyVal [1,1,0,0,0,0,0,0,1,1,1,1,1,1,0,1],PolyVal [0,0,0,1,0,0,0,1,1,0,0,1,1,0,1,1],PolyVal [1,1,1,1,0,1,0,0,0,1,1,1,1,1,0,1],PolyVal [1,0,0,1,1,0,0,1,0,1,1,1,0,1,0,1],PolyVal [0,1,1,0,0,0,0,1,0,0,0,1,0,1,1,1],PolyVal [0,0,1,0,1,1,1,0,1,1,0,0,0,0,1,0],PolyVal [1,0,1,0,0,1,0,0,1,0,1,0,1,0,0,0]],VectorVal [PolyVal [1,1,0,1,1,0,0,0,0,0,1,0,0,0,1,0],PolyVal [0,1,1,0,0,1,0,0,0,1,0,1,1,0,1,1],PolyVal [1,0,1,1,1,1,0,0,0,1,0,1,0,1,1,0],PolyVal [0,1,0,0,1,0,1,0,1,0,1,1,1,1,1,0],PolyVal [0,1,0,1,0,1,0,1,0,0,1,0,1,0,0,1],PolyVal [1,1,0,1,1,0,1,1,1,0,1,1,0,0,1,0],PolyVal [1,0,0,1,1,0,0,0,1,1,0,0,1,1,1,1],PolyVal [1,1,1,0,0,1,1,0,0,0,1,0,0,1,1,1]]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_p16(vcreate_p16(UINT64_C(0xbe2fd988bf0340d0)),
                          vcreate_p16(UINT64_C(0x15254374e886ae99)));
      arg2 = vcombine_p16(vcreate_p16(UINT64_C(0x7d526a3dda26441b)),
                          vcreate_p16(UINT64_C(0xe467f3194ddb94aa)));
      clear_neon_saturated();
      //  Expect: "result" = e46715254ddbe8867d52be2fda26bf03f319437494aaae996a3dd988441b40d0
      result = vtrnq_p16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p16(result.val[0]), 0);
         exp = UINT64_C(0x6a3dd988441b40d0);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p16(result.val[0]), 1);
         exp = UINT64_C(0xf319437494aaae99);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p16(result.val[1]), 0);
         exp = UINT64_C(0x7d52be2fda26bf03);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p16(result.val[1]), 1);
         exp = UINT64_C(0xe46715254ddbe886);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_3311() {

{
   {
      int8x8_t arg1;
      int8x8_t arg2;
      int8x8x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"zip\", fnname = \"vzip_s8\", rettype = \"int8x8x2_t\", argtypes = \"[int8x8_t,int8x8_t]\", vals = [VectorVal [IntegerVal (-128),IntegerVal 0,IntegerVal (-128),IntegerVal 56,IntegerVal (-1),IntegerVal (-1),IntegerVal (-28),IntegerVal (-35)],VectorVal [IntegerVal 127,IntegerVal (-82),IntegerVal (-128),IntegerVal (-1),IntegerVal 0,IntegerVal 0,IntegerVal (-1),IntegerVal (-1)]], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_s8(UINT64_C(0xdde4ffff38800080));
      arg2 = vcreate_s8(UINT64_C(0xffff0000ff80ae7f));
      clear_neon_saturated();
      //  Expect: "result" = ffddffe400ff00ffff388080ae007f80
      result = vzip_s8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_s8(result.val[0]), 0);
         exp = UINT64_C(0xff388080ae007f80);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_s8(result.val[1]), 0);
         exp = UINT64_C(0xffddffe400ff00ff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_3312() {

{
   {
      int16x4_t arg1;
      int16x4_t arg2;
      int16x4x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"zip\", fnname = \"vzip_s16\", rettype = \"int16x4x2_t\", argtypes = \"[int16x4_t,int16x4_t]\", vals = [VectorVal [IntegerVal 25677,IntegerVal 0,IntegerVal (-8881),IntegerVal (-32768)],VectorVal [IntegerVal (-32768),IntegerVal (-1),IntegerVal 31414,IntegerVal (-1)]], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_s16(UINT64_C(0x8000dd4f0000644d));
      arg2 = vcreate_s16(UINT64_C(0xffff7ab6ffff8000));
      clear_neon_saturated();
      //  Expect: "result" = ffff80007ab6dd4fffff00008000644d
      result = vzip_s16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_s16(result.val[0]), 0);
         exp = UINT64_C(0xffff00008000644d);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_s16(result.val[1]), 0);
         exp = UINT64_C(0xffff80007ab6dd4f);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_3313() {

{
   {
      int32x2_t arg1;
      int32x2_t arg2;
      int32x2x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"zip\", fnname = \"vzip_s32\", rettype = \"int32x2x2_t\", argtypes = \"[int32x2_t,int32x2_t]\", vals = [VectorVal [IntegerVal (-2147450881),IntegerVal 65535],VectorVal [IntegerVal (-32768),IntegerVal (-2147450881)]], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_s32(UINT64_C(0x0000ffff80007fff));
      arg2 = vcreate_s32(UINT64_C(0x80007fffffff8000));
      clear_neon_saturated();
      //  Expect: "result" = 80007fff0000ffffffff800080007fff
      result = vzip_s32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_s32(result.val[0]), 0);
         exp = UINT64_C(0xffff800080007fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_s32(result.val[1]), 0);
         exp = UINT64_C(0x80007fff0000ffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_3314() {

{
   {
      uint8x8_t arg1;
      uint8x8_t arg2;
      uint8x8x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"zip\", fnname = \"vzip_u8\", rettype = \"uint8x8x2_t\", argtypes = \"[uint8x8_t,uint8x8_t]\", vals = [VectorVal [IntegerVal 0,IntegerVal 127,IntegerVal 56,IntegerVal 128,IntegerVal 255,IntegerVal 255,IntegerVal 127,IntegerVal 39],VectorVal [IntegerVal 0,IntegerVal 127,IntegerVal 0,IntegerVal 128,IntegerVal 0,IntegerVal 255,IntegerVal 128,IntegerVal 0]], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_u8(UINT64_C(0x277fffff80387f00));
      arg2 = vcreate_u8(UINT64_C(0x0080ff0080007f00));
      clear_neon_saturated();
      //  Expect: "result" = 0027807fffff00ff808000387f7f0000
      result = vzip_u8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_u8(result.val[0]), 0);
         exp = UINT64_C(0x808000387f7f0000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_u8(result.val[1]), 0);
         exp = UINT64_C(0x0027807fffff00ff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_3315() {

{
   {
      uint16x4_t arg1;
      uint16x4_t arg2;
      uint16x4x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"zip\", fnname = \"vzip_u16\", rettype = \"uint16x4x2_t\", argtypes = \"[uint16x4_t,uint16x4_t]\", vals = [VectorVal [IntegerVal 32768,IntegerVal 32768,IntegerVal 3454,IntegerVal 0],VectorVal [IntegerVal 32767,IntegerVal 32767,IntegerVal 0,IntegerVal 53412]], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_u16(UINT64_C(0x00000d7e80008000));
      arg2 = vcreate_u16(UINT64_C(0xd0a400007fff7fff));
      clear_neon_saturated();
      //  Expect: "result" = d0a4000000000d7e7fff80007fff8000
      result = vzip_u16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_u16(result.val[0]), 0);
         exp = UINT64_C(0x7fff80007fff8000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_u16(result.val[1]), 0);
         exp = UINT64_C(0xd0a4000000000d7e);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_3316() {

{
   {
      uint32x2_t arg1;
      uint32x2_t arg2;
      uint32x2x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"zip\", fnname = \"vzip_u32\", rettype = \"uint32x2x2_t\", argtypes = \"[uint32x2_t,uint32x2_t]\", vals = [VectorVal [IntegerVal 2147483648,IntegerVal 2147450880],VectorVal [IntegerVal 65535,IntegerVal 2787475455]], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_u32(UINT64_C(0x7fff800080000000));
      arg2 = vcreate_u32(UINT64_C(0xa6257fff0000ffff));
      clear_neon_saturated();
      //  Expect: "result" = a6257fff7fff80000000ffff80000000
      result = vzip_u32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_u32(result.val[0]), 0);
         exp = UINT64_C(0x0000ffff80000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_u32(result.val[1]), 0);
         exp = UINT64_C(0xa6257fff7fff8000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_3317() {

{
   {
      poly8x8_t arg1;
      poly8x8_t arg2;
      poly8x8x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"zip\", fnname = \"vzip_p8\", rettype = \"poly8x8x2_t\", argtypes = \"[poly8x8_t,poly8x8_t]\", vals = [VectorVal [PolyVal [1,0,1,0,0,0,1,1],PolyVal [0,1,1,0,0,0,1,1],PolyVal [1,0,0,0,0,1,1,1],PolyVal [0,0,0,1,1,0,1,0],PolyVal [0,1,0,0,1,0,1,0],PolyVal [0,1,1,0,1,0,0,1],PolyVal [0,1,1,1,1,0,0,0],PolyVal [0,1,1,1,1,1,0,1]],VectorVal [PolyVal [0,1,1,0,1,0,1,0],PolyVal [1,0,0,1,1,1,0,0],PolyVal [0,1,1,0,0,1,0,1],PolyVal [1,0,0,1,1,1,0,1],PolyVal [1,1,0,0,0,0,1,1],PolyVal [1,1,0,0,0,0,0,1],PolyVal [0,1,0,1,1,0,1,0],PolyVal [0,0,0,1,1,0,0,0]]], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_p8(UINT64_C(0xbe1e965258e1c6c5));
      arg2 = vcreate_p8(UINT64_C(0x185a83c3b9a63956));
      clear_neon_saturated();
      //  Expect: "result" = 18be5a1e8396c352b958a6e139c656c5
      result = vzip_p8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_p8(result.val[0]), 0);
         exp = UINT64_C(0xb958a6e139c656c5);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_p8(result.val[1]), 0);
         exp = UINT64_C(0x18be5a1e8396c352);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_3318() {

{
   {
      poly16x4_t arg1;
      poly16x4_t arg2;
      poly16x4x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"zip\", fnname = \"vzip_p16\", rettype = \"poly16x4x2_t\", argtypes = \"[poly16x4_t,poly16x4_t]\", vals = [VectorVal [PolyVal [1,1,0,0,0,0,0,1,0,1,0,0,1,0,1,1],PolyVal [1,1,0,0,1,0,1,1,0,0,0,0,0,0,1,1],PolyVal [1,1,1,0,0,0,0,1,0,0,0,0,1,1,1,0],PolyVal [0,0,1,0,0,0,1,1,1,0,1,1,0,0,0,1]],VectorVal [PolyVal [1,0,0,1,0,1,1,0,1,1,1,0,0,0,1,1],PolyVal [1,0,1,1,0,1,1,0,0,0,0,1,1,0,0,0],PolyVal [1,1,1,0,0,0,0,0,0,1,1,1,0,0,1,1],PolyVal [0,1,0,1,0,1,1,1,0,1,0,0,1,0,0,1]]], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_p16(UINT64_C(0x8dc47087c0d3d283));
      arg2 = vcreate_p16(UINT64_C(0x92eace07186dc769));
      clear_neon_saturated();
      //  Expect: "result" = 92ea8dc4ce077087186dc0d3c769d283
      result = vzip_p16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_p16(result.val[0]), 0);
         exp = UINT64_C(0x186dc0d3c769d283);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_p16(result.val[1]), 0);
         exp = UINT64_C(0x92ea8dc4ce077087);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_3319() {

{
   {
      float32x2_t arg1;
      float32x2_t arg2;
      float32x2x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"zip\", fnname = \"vzip_f32\", rettype = \"float32x2x2_t\", argtypes = \"[float32x2_t,float32x2_t]\", vals = [VectorVal [FloatVal 0.16752463579177856,FloatVal 0.39735275506973267],VectorVal [FloatVal 0.8749776482582092,FloatVal 0.17954355478286743]], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_f32(UINT64_C(0x3ecb71d23e2b8b94));
      arg2 = vcreate_f32(UINT64_C(0x3e37da443f5ffe89));
      clear_neon_saturated();
      //  Expect: "result" = 3e37da443ecb71d23f5ffe893e2b8b94
      result = vzip_f32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result.val[0], 0);
         exp = ((float32_t) 0.16752463579177856);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 0 ",
                      exp,
                      got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result.val[0], 1);
         exp = ((float32_t) 0.8749776482582092);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 1 ",
                      exp,
                      got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result.val[1], 0);
         exp = ((float32_t) 0.39735275506973267);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 0 ",
                      exp,
                      got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result.val[1], 1);
         exp = ((float32_t) 0.17954355478286743);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 1 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_3320() {

{
   {
      int8x16_t arg1;
      int8x16_t arg2;
      int8x16x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"zip\", fnname = \"vzipq_s8\", rettype = \"int8x16x2_t\", argtypes = \"[int8x16_t,int8x16_t]\", vals = [VectorVal [IntegerVal 127,IntegerVal 0,IntegerVal (-67),IntegerVal 65,IntegerVal (-1),IntegerVal (-128),IntegerVal (-128),IntegerVal (-1),IntegerVal (-1),IntegerVal (-128),IntegerVal (-1),IntegerVal 0,IntegerVal (-1),IntegerVal (-128),IntegerVal 75,IntegerVal (-128)],VectorVal [IntegerVal (-128),IntegerVal 65,IntegerVal (-1),IntegerVal 127,IntegerVal 127,IntegerVal (-1),IntegerVal 124,IntegerVal 127,IntegerVal (-128),IntegerVal (-1),IntegerVal 127,IntegerVal (-1),IntegerVal (-122),IntegerVal (-1),IntegerVal 0,IntegerVal (-1)]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s8(vcreate_s8(UINT64_C(0xff8080ff41bd007f)),
                         vcreate_s8(UINT64_C(0x804b80ff00ff80ff)));
      arg2 = vcombine_s8(vcreate_s8(UINT64_C(0x7f7cff7f7fff4180)),
                         vcreate_s8(UINT64_C(0xff00ff86ff7fff80)));
      clear_neon_saturated();
      //  Expect: "result" = ff80004bff8086ffff007fffff8080ff7fff7c80ff807fff7f41ffbd4100807f
      result = vzipq_s8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result.val[0]), 0);
         exp = UINT64_C(0x7f41ffbd4100807f);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result.val[0]), 1);
         exp = UINT64_C(0x7fff7c80ff807fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result.val[1]), 0);
         exp = UINT64_C(0xff007fffff8080ff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result.val[1]), 1);
         exp = UINT64_C(0xff80004bff8086ff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_3321() {

{
   {
      int16x8_t arg1;
      int16x8_t arg2;
      int16x8x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"zip\", fnname = \"vzipq_s16\", rettype = \"int16x8x2_t\", argtypes = \"[int16x8_t,int16x8_t]\", vals = [VectorVal [IntegerVal 0,IntegerVal (-21515),IntegerVal 32767,IntegerVal (-1),IntegerVal 0,IntegerVal (-32768),IntegerVal 22862,IntegerVal (-1)],VectorVal [IntegerVal 32767,IntegerVal 31951,IntegerVal 32767,IntegerVal 14594,IntegerVal 32767,IntegerVal 32767,IntegerVal 0,IntegerVal 0]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s16(vcreate_s16(UINT64_C(0xffff7fffabf50000)),
                          vcreate_s16(UINT64_C(0xffff594e80000000)));
      arg2 = vcombine_s16(vcreate_s16(UINT64_C(0x39027fff7ccf7fff)),
                          vcreate_s16(UINT64_C(0x000000007fff7fff)));
      clear_neon_saturated();
      //  Expect: "result" = 0000ffff0000594e7fff80007fff00003902ffff7fff7fff7ccfabf57fff0000
      result = vzipq_s16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result.val[0]), 0);
         exp = UINT64_C(0x7ccfabf57fff0000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result.val[0]), 1);
         exp = UINT64_C(0x3902ffff7fff7fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result.val[1]), 0);
         exp = UINT64_C(0x7fff80007fff0000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result.val[1]), 1);
         exp = UINT64_C(0x0000ffff0000594e);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_3322() {

{
   {
      int32x4_t arg1;
      int32x4_t arg2;
      int32x4x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"zip\", fnname = \"vzipq_s32\", rettype = \"int32x4x2_t\", argtypes = \"[int32x4_t,int32x4_t]\", vals = [VectorVal [IntegerVal (-2147450880),IntegerVal 2147418112,IntegerVal (-32768),IntegerVal 2147450879],VectorVal [IntegerVal (-2147450881),IntegerVal 2147418112,IntegerVal (-65536),IntegerVal 2147418112]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s32(vcreate_s32(UINT64_C(0x7fff000080008000)),
                          vcreate_s32(UINT64_C(0x7fff7fffffff8000)));
      arg2 = vcombine_s32(vcreate_s32(UINT64_C(0x7fff000080007fff)),
                          vcreate_s32(UINT64_C(0x7fff0000ffff0000)));
      clear_neon_saturated();
      //  Expect: "result" = 7fff00007fff7fffffff0000ffff80007fff00007fff000080007fff80008000
      result = vzipq_s32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result.val[0]), 0);
         exp = UINT64_C(0x80007fff80008000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result.val[0]), 1);
         exp = UINT64_C(0x7fff00007fff0000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result.val[1]), 0);
         exp = UINT64_C(0xffff0000ffff8000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result.val[1]), 1);
         exp = UINT64_C(0x7fff00007fff7fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_3323() {

{
   {
      uint8x16_t arg1;
      uint8x16_t arg2;
      uint8x16x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"zip\", fnname = \"vzipq_u8\", rettype = \"uint8x16x2_t\", argtypes = \"[uint8x16_t,uint8x16_t]\", vals = [VectorVal [IntegerVal 127,IntegerVal 0,IntegerVal 255,IntegerVal 255,IntegerVal 0,IntegerVal 89,IntegerVal 255,IntegerVal 127,IntegerVal 3,IntegerVal 255,IntegerVal 255,IntegerVal 0,IntegerVal 127,IntegerVal 15,IntegerVal 239,IntegerVal 89],VectorVal [IntegerVal 128,IntegerVal 8,IntegerVal 128,IntegerVal 128,IntegerVal 128,IntegerVal 106,IntegerVal 255,IntegerVal 128,IntegerVal 128,IntegerVal 127,IntegerVal 128,IntegerVal 127,IntegerVal 128,IntegerVal 128,IntegerVal 0,IntegerVal 128]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u8(vcreate_u8(UINT64_C(0x7fff5900ffff007f)),
                         vcreate_u8(UINT64_C(0x59ef0f7f00ffff03)));
      arg2 = vcombine_u8(vcreate_u8(UINT64_C(0x80ff6a8080800880)),
                         vcreate_u8(UINT64_C(0x800080807f807f80)));
      clear_neon_saturated();
      //  Expect: "result" = 805900ef800f807f7f0080ff7fff8003807fffff6a59800080ff80ff0800807f
      result = vzipq_u8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result.val[0]), 0);
         exp = UINT64_C(0x80ff80ff0800807f);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result.val[0]), 1);
         exp = UINT64_C(0x807fffff6a598000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result.val[1]), 0);
         exp = UINT64_C(0x7f0080ff7fff8003);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result.val[1]), 1);
         exp = UINT64_C(0x805900ef800f807f);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_3324() {

{
   {
      uint16x8_t arg1;
      uint16x8_t arg2;
      uint16x8x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"zip\", fnname = \"vzipq_u16\", rettype = \"uint16x8x2_t\", argtypes = \"[uint16x8_t,uint16x8_t]\", vals = [VectorVal [IntegerVal 0,IntegerVal 27306,IntegerVal 0,IntegerVal 32768,IntegerVal 0,IntegerVal 32768,IntegerVal 32767,IntegerVal 65535],VectorVal [IntegerVal 0,IntegerVal 0,IntegerVal 65535,IntegerVal 32767,IntegerVal 24662,IntegerVal 32768,IntegerVal 0,IntegerVal 32767]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u16(vcreate_u16(UINT64_C(0x800000006aaa0000)),
                          vcreate_u16(UINT64_C(0xffff7fff80000000)));
      arg2 = vcombine_u16(vcreate_u16(UINT64_C(0x7fffffff00000000)),
                          vcreate_u16(UINT64_C(0x7fff000080006056)));
      clear_neon_saturated();
      //  Expect: "result" = 7fffffff00007fff80008000605600007fff8000ffff000000006aaa00000000
      result = vzipq_u16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result.val[0]), 0);
         exp = UINT64_C(0x00006aaa00000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result.val[0]), 1);
         exp = UINT64_C(0x7fff8000ffff0000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result.val[1]), 0);
         exp = UINT64_C(0x8000800060560000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result.val[1]), 1);
         exp = UINT64_C(0x7fffffff00007fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_3325() {

{
   {
      uint32x4_t arg1;
      uint32x4_t arg2;
      uint32x4x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"zip\", fnname = \"vzipq_u32\", rettype = \"uint32x4x2_t\", argtypes = \"[uint32x4_t,uint32x4_t]\", vals = [VectorVal [IntegerVal 3379920895,IntegerVal 2072805376,IntegerVal 4294934528,IntegerVal 2147483648],VectorVal [IntegerVal 4294927471,IntegerVal 2147549183,IntegerVal 2147483648,IntegerVal 2147516416]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u32(vcreate_u32(UINT64_C(0x7b8c8000c9757fff)),
                          vcreate_u32(UINT64_C(0x80000000ffff8000)));
      arg2 = vcombine_u32(vcreate_u32(UINT64_C(0x8000ffffffff646f)),
                          vcreate_u32(UINT64_C(0x8000800080000000)));
      clear_neon_saturated();
      //  Expect: "result" = 800080008000000080000000ffff80008000ffff7b8c8000ffff646fc9757fff
      result = vzipq_u32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result.val[0]), 0);
         exp = UINT64_C(0xffff646fc9757fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result.val[0]), 1);
         exp = UINT64_C(0x8000ffff7b8c8000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result.val[1]), 0);
         exp = UINT64_C(0x80000000ffff8000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result.val[1]), 1);
         exp = UINT64_C(0x8000800080000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_3326() {

{
   {
      poly8x16_t arg1;
      poly8x16_t arg2;
      poly8x16x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"zip\", fnname = \"vzipq_p8\", rettype = \"poly8x16x2_t\", argtypes = \"[poly8x16_t,poly8x16_t]\", vals = [VectorVal [PolyVal [1,1,0,0,1,1,0,1],PolyVal [0,1,0,1,1,0,1,0],PolyVal [0,1,0,1,1,0,1,1],PolyVal [0,0,1,0,0,0,0,1],PolyVal [0,1,0,1,1,1,1,1],PolyVal [1,0,1,1,0,1,1,0],PolyVal [1,0,1,1,1,0,1,1],PolyVal [0,1,0,1,0,0,0,1],PolyVal [1,1,1,0,1,0,0,1],PolyVal [0,1,1,0,0,0,0,1],PolyVal [1,1,1,0,0,1,0,0],PolyVal [1,1,0,0,1,1,0,1],PolyVal [0,0,0,0,1,1,1,0],PolyVal [0,0,0,1,1,1,0,0],PolyVal [0,0,1,1,1,1,0,1],PolyVal [1,1,1,0,1,1,1,1]],VectorVal [PolyVal [1,0,0,1,0,1,1,0],PolyVal [0,1,0,0,0,0,0,1],PolyVal [0,0,1,0,1,1,0,1],PolyVal [1,0,1,1,0,1,0,1],PolyVal [1,1,0,0,1,1,1,1],PolyVal [0,1,1,0,0,1,1,1],PolyVal [0,1,1,1,0,1,1,0],PolyVal [0,1,0,1,1,1,1,0],PolyVal [1,1,0,0,1,0,1,0],PolyVal [0,0,0,1,1,0,1,1],PolyVal [0,0,0,1,0,1,0,0],PolyVal [0,1,1,0,0,1,1,0],PolyVal [1,1,1,1,0,1,0,1],PolyVal [1,0,0,1,1,1,0,1],PolyVal [0,0,1,1,0,1,1,0],PolyVal [1,0,0,0,0,1,0,1]]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_p8(vcreate_p8(UINT64_C(0x8add6dfa84da5ab3)),
                         vcreate_p8(UINT64_C(0xf7bc3870b3278697)));
      arg2 = vcombine_p8(vcreate_p8(UINT64_C(0x7a6ee6f3adb48269)),
                         vcreate_p8(UINT64_C(0xa16cb9af6628d853)));
      clear_neon_saturated();
      //  Expect: "result" = a1f76cbcb938af7066b32827d88653977a8a6edde66df3faad84b4da825a69b3
      result = vzipq_p8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p8(result.val[0]), 0);
         exp = UINT64_C(0xad84b4da825a69b3);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p8(result.val[0]), 1);
         exp = UINT64_C(0x7a8a6edde66df3fa);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p8(result.val[1]), 0);
         exp = UINT64_C(0x66b32827d8865397);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p8(result.val[1]), 1);
         exp = UINT64_C(0xa1f76cbcb938af70);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_3327() {

{
   {
      poly16x8_t arg1;
      poly16x8_t arg2;
      poly16x8x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"zip\", fnname = \"vzipq_p16\", rettype = \"poly16x8x2_t\", argtypes = \"[poly16x8_t,poly16x8_t]\", vals = [VectorVal [PolyVal [1,0,0,0,0,0,0,0,1,0,1,0,0,0,1,1],PolyVal [1,0,1,0,1,0,0,1,0,1,1,1,1,0,1,1],PolyVal [0,0,1,0,1,0,0,1,0,1,0,0,1,1,0,0],PolyVal [1,0,1,0,1,0,0,0,1,1,0,1,0,1,0,1],PolyVal [1,1,1,1,1,1,0,1,1,0,0,1,0,1,0,1],PolyVal [1,0,1,0,1,1,1,0,0,0,1,0,0,1,1,1],PolyVal [0,0,0,0,0,0,1,1,0,0,0,1,1,1,0,1],PolyVal [0,0,1,1,1,0,0,1,1,0,0,1,1,1,1,0]],VectorVal [PolyVal [1,0,1,0,1,0,1,0,1,1,0,1,1,0,1,1],PolyVal [0,1,0,1,1,0,1,1,1,0,1,1,1,1,0,1],PolyVal [0,1,0,0,1,0,1,0,0,0,1,1,0,0,1,1],PolyVal [0,0,0,1,0,1,0,0,1,1,1,1,1,1,0,0],PolyVal [0,0,0,1,0,0,1,1,1,1,0,0,1,0,0,1],PolyVal [1,1,0,0,0,1,1,0,0,0,0,0,1,0,0,1],PolyVal [0,1,1,1,1,0,0,0,1,1,0,1,1,0,1,0],PolyVal [1,0,1,1,0,1,0,0,1,0,0,1,0,0,0,0]]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_p16(vcreate_p16(UINT64_C(0xab153294de95c501)),
                          vcreate_p16(UINT64_C(0x799cb8c0e475a9bf)));
      arg2 = vcombine_p16(vcreate_p16(UINT64_C(0x3f28cc52bddadb55)),
                          vcreate_p16(UINT64_C(0x092d5b1e906393c8)));
      clear_neon_saturated();
      //  Expect: "result" = 092d799c5b1eb8c09063e47593c8a9bf3f28ab15cc523294bddade95db55c501
      result = vzipq_p16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p16(result.val[0]), 0);
         exp = UINT64_C(0xbddade95db55c501);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p16(result.val[0]), 1);
         exp = UINT64_C(0x3f28ab15cc523294);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p16(result.val[1]), 0);
         exp = UINT64_C(0x9063e47593c8a9bf);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p16(result.val[1]), 1);
         exp = UINT64_C(0x092d799c5b1eb8c0);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_3328() {

{
   {
      float32x4_t arg1;
      float32x4_t arg2;
      float32x4x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"zip\", fnname = \"vzipq_f32\", rettype = \"float32x4x2_t\", argtypes = \"[float32x4_t,float32x4_t]\", vals = [VectorVal [FloatVal 0.8926634192466736,FloatVal 0.880665123462677,FloatVal 0.8032406568527222,FloatVal 0.7282366752624512],VectorVal [FloatVal 0.9731155633926392,FloatVal 0.3246210813522339,FloatVal 0.9892411828041077,FloatVal 0.5625099539756775]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_f32(vcreate_f32(UINT64_C(0x3f6173453f648597)),
                          vcreate_f32(UINT64_C(0x3f3a6db83f4da12e)));
      arg2 = vcombine_f32(vcreate_f32(UINT64_C(0x3ea634bc3f791e1a)),
                          vcreate_f32(UINT64_C(0x3f1000a73f7d3ee9)));
      clear_neon_saturated();
      //  Expect: "result" = 3f1000a73f3a6db83f7d3ee93f4da12e3ea634bc3f6173453f791e1a3f648597
      result = vzipq_f32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result.val[0], 0);
         exp = ((float32_t) 0.8926634192466736);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 0 ",
                      exp,
                      got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result.val[0], 1);
         exp = ((float32_t) 0.9731155633926392);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 1 ",
                      exp,
                      got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result.val[0], 2);
         exp = ((float32_t) 0.880665123462677);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 2 ",
                      exp,
                      got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result.val[0], 3);
         exp = ((float32_t) 0.3246210813522339);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 3 ",
                      exp,
                      got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result.val[1], 0);
         exp = ((float32_t) 0.8032406568527222);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 0 ",
                      exp,
                      got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result.val[1], 1);
         exp = ((float32_t) 0.9892411828041077);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 1 ",
                      exp,
                      got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result.val[1], 2);
         exp = ((float32_t) 0.7282366752624512);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 2 ",
                      exp,
                      got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result.val[1], 3);
         exp = ((float32_t) 0.5625099539756775);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 3 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_3329() {

{
   {
      int8x8_t arg1;
      int8x8_t arg2;
      int8x8x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"uzp\", fnname = \"vuzp_s8\", rettype = \"int8x8x2_t\", argtypes = \"[int8x8_t,int8x8_t]\", vals = [VectorVal [IntegerVal (-70),IntegerVal (-1),IntegerVal (-128),IntegerVal 0,IntegerVal 0,IntegerVal (-1),IntegerVal (-1),IntegerVal 127],VectorVal [IntegerVal 127,IntegerVal 111,IntegerVal 0,IntegerVal 127,IntegerVal (-128),IntegerVal 32,IntegerVal 127,IntegerVal (-1)]], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_s8(UINT64_C(0x7fffff000080ffba));
      arg2 = vcreate_s8(UINT64_C(0xff7f20807f006f7f));
      clear_neon_saturated();
      //  Expect: "result" = ff207f6f7fff00ff7f80007fff0080ba
      result = vuzp_s8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_s8(result.val[0]), 0);
         exp = UINT64_C(0x7f80007fff0080ba);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_s8(result.val[1]), 0);
         exp = UINT64_C(0xff207f6f7fff00ff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_3330() {

{
   {
      int16x4_t arg1;
      int16x4_t arg2;
      int16x4x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"uzp\", fnname = \"vuzp_s16\", rettype = \"int16x4x2_t\", argtypes = \"[int16x4_t,int16x4_t]\", vals = [VectorVal [IntegerVal 5176,IntegerVal 32767,IntegerVal 11852,IntegerVal (-32768)],VectorVal [IntegerVal (-32564),IntegerVal (-3055),IntegerVal 3141,IntegerVal (-32768)]], start_saturated = True}";
      int reported = 0;
      arg1 = vcreate_s16(UINT64_C(0x80002e4c7fff1438));
      arg2 = vcreate_s16(UINT64_C(0x80000c45f41180cc));
      set_neon_saturated();
      //  Expect: "result" = 8000f41180007fff0c4580cc2e4c1438
      result = vuzp_s16(arg1, arg2);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_s16(result.val[0]), 0);
         exp = UINT64_C(0x0c4580cc2e4c1438);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_s16(result.val[1]), 0);
         exp = UINT64_C(0x8000f41180007fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_3331() {

{
   {
      int32x2_t arg1;
      int32x2_t arg2;
      int32x2x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"uzp\", fnname = \"vuzp_s32\", rettype = \"int32x2x2_t\", argtypes = \"[int32x2_t,int32x2_t]\", vals = [VectorVal [IntegerVal (-65536),IntegerVal 27282],VectorVal [IntegerVal 1593671679,IntegerVal 2147450879]], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_s32(UINT64_C(0x00006a92ffff0000));
      arg2 = vcreate_s32(UINT64_C(0x7fff7fff5efd7fff));
      clear_neon_saturated();
      //  Expect: "result" = 7fff7fff00006a925efd7fffffff0000
      result = vuzp_s32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_s32(result.val[0]), 0);
         exp = UINT64_C(0x5efd7fffffff0000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_s32(result.val[1]), 0);
         exp = UINT64_C(0x7fff7fff00006a92);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_3332() {

{
   {
      uint8x8_t arg1;
      uint8x8_t arg2;
      uint8x8x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"uzp\", fnname = \"vuzp_u8\", rettype = \"uint8x8x2_t\", argtypes = \"[uint8x8_t,uint8x8_t]\", vals = [VectorVal [IntegerVal 127,IntegerVal 208,IntegerVal 255,IntegerVal 127,IntegerVal 128,IntegerVal 146,IntegerVal 128,IntegerVal 0],VectorVal [IntegerVal 127,IntegerVal 128,IntegerVal 128,IntegerVal 0,IntegerVal 222,IntegerVal 255,IntegerVal 255,IntegerVal 0]], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_u8(UINT64_C(0x008092807fffd07f));
      arg2 = vcreate_u8(UINT64_C(0x00ffffde0080807f));
      clear_neon_saturated();
      //  Expect: "result" = 00ff008000927fd0ffde807f8080ff7f
      result = vuzp_u8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_u8(result.val[0]), 0);
         exp = UINT64_C(0xffde807f8080ff7f);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_u8(result.val[1]), 0);
         exp = UINT64_C(0x00ff008000927fd0);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_3333() {

{
   {
      uint16x4_t arg1;
      uint16x4_t arg2;
      uint16x4x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"uzp\", fnname = \"vuzp_u16\", rettype = \"uint16x4x2_t\", argtypes = \"[uint16x4_t,uint16x4_t]\", vals = [VectorVal [IntegerVal 32768,IntegerVal 32768,IntegerVal 32767,IntegerVal 8777],VectorVal [IntegerVal 32767,IntegerVal 65535,IntegerVal 4053,IntegerVal 64149]], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_u16(UINT64_C(0x22497fff80008000));
      arg2 = vcreate_u16(UINT64_C(0xfa950fd5ffff7fff));
      clear_neon_saturated();
      //  Expect: "result" = fa95ffff224980000fd57fff7fff8000
      result = vuzp_u16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_u16(result.val[0]), 0);
         exp = UINT64_C(0x0fd57fff7fff8000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_u16(result.val[1]), 0);
         exp = UINT64_C(0xfa95ffff22498000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_3334() {

{
   {
      uint32x2_t arg1;
      uint32x2_t arg2;
      uint32x2x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"uzp\", fnname = \"vuzp_u32\", rettype = \"uint32x2x2_t\", argtypes = \"[uint32x2_t,uint32x2_t]\", vals = [VectorVal [IntegerVal 2147450880,IntegerVal 2147483647],VectorVal [IntegerVal 2147450880,IntegerVal 2369880064]], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_u32(UINT64_C(0x7fffffff7fff8000));
      arg2 = vcreate_u32(UINT64_C(0x8d4180007fff8000));
      clear_neon_saturated();
      //  Expect: "result" = 8d4180007fffffff7fff80007fff8000
      result = vuzp_u32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_u32(result.val[0]), 0);
         exp = UINT64_C(0x7fff80007fff8000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_u32(result.val[1]), 0);
         exp = UINT64_C(0x8d4180007fffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_3335() {

{
   {
      poly8x8_t arg1;
      poly8x8_t arg2;
      poly8x8x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"uzp\", fnname = \"vuzp_p8\", rettype = \"poly8x8x2_t\", argtypes = \"[poly8x8_t,poly8x8_t]\", vals = [VectorVal [PolyVal [1,1,0,0,0,1,0,1],PolyVal [0,0,1,1,1,0,1,0],PolyVal [0,1,0,1,0,0,1,0],PolyVal [0,1,0,0,0,1,1,1],PolyVal [1,1,0,1,0,1,0,1],PolyVal [0,1,1,0,0,1,0,1],PolyVal [1,0,1,1,0,1,1,1],PolyVal [0,0,1,0,1,0,1,0]],VectorVal [PolyVal [0,0,1,1,1,1,0,1],PolyVal [0,0,1,1,1,1,1,0],PolyVal [0,0,1,0,0,0,0,1],PolyVal [0,1,1,1,0,0,1,0],PolyVal [0,1,1,0,1,1,0,0],PolyVal [0,0,0,1,0,1,0,0],PolyVal [1,0,0,0,1,1,0,1],PolyVal [1,0,1,1,0,0,0,1]]], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_p8(UINT64_C(0x54eda6abe24a5ca3));
      arg2 = vcreate_p8(UINT64_C(0x8db128364e847cbc));
      clear_neon_saturated();
      //  Expect: "result" = 8d284e7c54a6e25cb13684bcedab4aa3
      result = vuzp_p8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_p8(result.val[0]), 0);
         exp = UINT64_C(0xb13684bcedab4aa3);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_p8(result.val[1]), 0);
         exp = UINT64_C(0x8d284e7c54a6e25c);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_3336() {

{
   {
      poly16x4_t arg1;
      poly16x4_t arg2;
      poly16x4x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"uzp\", fnname = \"vuzp_p16\", rettype = \"poly16x4x2_t\", argtypes = \"[poly16x4_t,poly16x4_t]\", vals = [VectorVal [PolyVal [1,1,0,0,0,1,0,0,0,0,1,0,1,1,0,1],PolyVal [1,1,0,1,0,0,0,1,1,0,0,1,0,0,1,1],PolyVal [1,1,0,1,0,1,1,0,1,0,0,0,1,1,0,0],PolyVal [0,0,0,1,1,1,1,1,0,0,0,0,1,0,0,0]],VectorVal [PolyVal [0,1,0,1,1,0,0,1,0,0,0,0,1,0,1,0],PolyVal [1,1,1,1,1,1,1,0,1,1,1,0,0,0,1,0],PolyVal [0,1,1,0,1,0,1,0,0,0,0,1,0,0,1,1],PolyVal [1,0,1,0,0,1,0,1,1,1,1,1,1,1,1,0]]], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_p16(UINT64_C(0x10f8316bc98bb423));
      arg2 = vcreate_p16(UINT64_C(0x7fa5c856477f509a));
      clear_neon_saturated();
      //  Expect: "result" = 7fa5477f10f8c98bc856509a316bb423
      result = vuzp_p16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_p16(result.val[0]), 0);
         exp = UINT64_C(0xc856509a316bb423);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vget_lane_u64(vreinterpret_u64_p16(result.val[1]), 0);
         exp = UINT64_C(0x7fa5477f10f8c98b);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_3337() {

{
   {
      float32x2_t arg1;
      float32x2_t arg2;
      float32x2x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"uzp\", fnname = \"vuzp_f32\", rettype = \"float32x2x2_t\", argtypes = \"[float32x2_t,float32x2_t]\", vals = [VectorVal [FloatVal 0.5557001233100891,FloatVal 0.41940903663635254],VectorVal [FloatVal 7.840180397033691e-2,FloatVal 0.8319541215896606]], start_saturated = False}";
      int reported = 0;
      arg1 = vcreate_f32(UINT64_C(0x3ed6bcc83f0e425d));
      arg2 = vcreate_f32(UINT64_C(0x3f54faf23da09120));
      clear_neon_saturated();
      //  Expect: "result" = 3f54faf23ed6bcc83da091203f0e425d
      result = vuzp_f32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result.val[0], 0);
         exp = ((float32_t) 0.5557001233100891);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 0 ",
                      exp,
                      got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result.val[0], 1);
         exp = ((float32_t) 7.840180397033691e-2);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 1 ",
                      exp,
                      got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result.val[1], 0);
         exp = ((float32_t) 0.41940903663635254);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 0 ",
                      exp,
                      got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vget_lane_f32(result.val[1], 1);
         exp = ((float32_t) 0.8319541215896606);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 1 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_3338() {

{
   {
      int8x16_t arg1;
      int8x16_t arg2;
      int8x16x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"uzp\", fnname = \"vuzpq_s8\", rettype = \"int8x16x2_t\", argtypes = \"[int8x16_t,int8x16_t]\", vals = [VectorVal [IntegerVal (-128),IntegerVal 0,IntegerVal 127,IntegerVal (-128),IntegerVal (-126),IntegerVal (-1),IntegerVal (-15),IntegerVal (-1),IntegerVal (-1),IntegerVal (-128),IntegerVal 127,IntegerVal (-1),IntegerVal (-128),IntegerVal 0,IntegerVal (-1),IntegerVal (-1)],VectorVal [IntegerVal (-1),IntegerVal 0,IntegerVal (-128),IntegerVal (-128),IntegerVal (-108),IntegerVal (-1),IntegerVal 127,IntegerVal (-38),IntegerVal 0,IntegerVal (-7),IntegerVal 0,IntegerVal (-128),IntegerVal 0,IntegerVal 0,IntegerVal 0,IntegerVal (-37)]], start_saturated = True}";
      int reported = 0;
      arg1 = vcombine_s8(vcreate_s8(UINT64_C(0xfff1ff82807f0080)),
                         vcreate_s8(UINT64_C(0xffff0080ff7f80ff)));
      arg2 = vcombine_s8(vcreate_s8(UINT64_C(0xda7fff94808000ff)),
                         vcreate_s8(UINT64_C(0xdb0000008000f900)));
      set_neon_saturated();
      //  Expect: "result" = db0080f9daff8000ff00ff80ffff8000000000007f9480ffff807ffff1827f80
      result = vuzpq_s8(arg1, arg2);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result.val[0]), 0);
         exp = UINT64_C(0xff807ffff1827f80);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result.val[0]), 1);
         exp = UINT64_C(0x000000007f9480ff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result.val[1]), 0);
         exp = UINT64_C(0xff00ff80ffff8000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s8(result.val[1]), 1);
         exp = UINT64_C(0xdb0080f9daff8000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_3339() {

{
   {
      int16x8_t arg1;
      int16x8_t arg2;
      int16x8x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"uzp\", fnname = \"vuzpq_s16\", rettype = \"int16x8x2_t\", argtypes = \"[int16x8_t,int16x8_t]\", vals = [VectorVal [IntegerVal (-1),IntegerVal (-824),IntegerVal 32767,IntegerVal (-7351),IntegerVal (-32768),IntegerVal 0,IntegerVal 0,IntegerVal 31635],VectorVal [IntegerVal 32767,IntegerVal 32767,IntegerVal (-1),IntegerVal (-32768),IntegerVal (-11141),IntegerVal (-32768),IntegerVal 32767,IntegerVal 0]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s16(vcreate_s16(UINT64_C(0xe3497ffffcc8ffff)),
                          vcreate_s16(UINT64_C(0x7b93000000008000)));
      arg2 = vcombine_s16(vcreate_s16(UINT64_C(0x8000ffff7fff7fff)),
                          vcreate_s16(UINT64_C(0x00007fff8000d47b)));
      clear_neon_saturated();
      //  Expect: "result" = 0000800080007fff7b930000e349fcc87fffd47bffff7fff000080007fffffff
      result = vuzpq_s16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result.val[0]), 0);
         exp = UINT64_C(0x000080007fffffff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result.val[0]), 1);
         exp = UINT64_C(0x7fffd47bffff7fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result.val[1]), 0);
         exp = UINT64_C(0x7b930000e349fcc8);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s16(result.val[1]), 1);
         exp = UINT64_C(0x0000800080007fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_3340() {

{
   {
      int32x4_t arg1;
      int32x4_t arg2;
      int32x4x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"uzp\", fnname = \"vuzpq_s32\", rettype = \"int32x4x2_t\", argtypes = \"[int32x4_t,int32x4_t]\", vals = [VectorVal [IntegerVal (-1857864176),IntegerVal (-896598017),IntegerVal (-32769),IntegerVal 1322],VectorVal [IntegerVal (-39994),IntegerVal (-32768),IntegerVal (-2147483648),IntegerVal 32768]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_s32(vcreate_s32(UINT64_C(0xca8effff91433e10)),
                          vcreate_s32(UINT64_C(0x0000052affff7fff)));
      arg2 = vcombine_s32(vcreate_s32(UINT64_C(0xffff8000ffff63c6)),
                          vcreate_s32(UINT64_C(0x0000800080000000)));
      clear_neon_saturated();
      //  Expect: "result" = 00008000ffff80000000052aca8effff80000000ffff63c6ffff7fff91433e10
      result = vuzpq_s32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result.val[0]), 0);
         exp = UINT64_C(0xffff7fff91433e10);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result.val[0]), 1);
         exp = UINT64_C(0x80000000ffff63c6);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result.val[1]), 0);
         exp = UINT64_C(0x0000052aca8effff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_s32(result.val[1]), 1);
         exp = UINT64_C(0x00008000ffff8000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_3341() {

{
   {
      uint8x16_t arg1;
      uint8x16_t arg2;
      uint8x16x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"uzp\", fnname = \"vuzpq_u8\", rettype = \"uint8x16x2_t\", argtypes = \"[uint8x16_t,uint8x16_t]\", vals = [VectorVal [IntegerVal 127,IntegerVal 255,IntegerVal 255,IntegerVal 0,IntegerVal 128,IntegerVal 142,IntegerVal 0,IntegerVal 0,IntegerVal 155,IntegerVal 128,IntegerVal 127,IntegerVal 0,IntegerVal 127,IntegerVal 216,IntegerVal 128,IntegerVal 0],VectorVal [IntegerVal 255,IntegerVal 0,IntegerVal 0,IntegerVal 255,IntegerVal 0,IntegerVal 0,IntegerVal 32,IntegerVal 128,IntegerVal 128,IntegerVal 255,IntegerVal 255,IntegerVal 255,IntegerVal 127,IntegerVal 127,IntegerVal 128,IntegerVal 204]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u8(vcreate_u8(UINT64_C(0x00008e8000ffff7f)),
                         vcreate_u8(UINT64_C(0x0080d87f007f809b)));
      arg2 = vcombine_u8(vcreate_u8(UINT64_C(0x80200000ff0000ff)),
                         vcreate_u8(UINT64_C(0xcc807f7fffffff80)));
      clear_neon_saturated();
      //  Expect: "result" = cc7fffff8000ff0000d80080008e00ff807fff80200000ff807f7f9b0080ff7f
      result = vuzpq_u8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result.val[0]), 0);
         exp = UINT64_C(0x807f7f9b0080ff7f);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result.val[0]), 1);
         exp = UINT64_C(0x807fff80200000ff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result.val[1]), 0);
         exp = UINT64_C(0x00d80080008e00ff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u8(result.val[1]), 1);
         exp = UINT64_C(0xcc7fffff8000ff00);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_3342() {

{
   {
      uint16x8_t arg1;
      uint16x8_t arg2;
      uint16x8x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"uzp\", fnname = \"vuzpq_u16\", rettype = \"uint16x8x2_t\", argtypes = \"[uint16x8_t,uint16x8_t]\", vals = [VectorVal [IntegerVal 5913,IntegerVal 32768,IntegerVal 0,IntegerVal 20899,IntegerVal 103,IntegerVal 16968,IntegerVal 0,IntegerVal 0],VectorVal [IntegerVal 32767,IntegerVal 55805,IntegerVal 32767,IntegerVal 65535,IntegerVal 65535,IntegerVal 0,IntegerVal 27743,IntegerVal 32767]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u16(vcreate_u16(UINT64_C(0x51a3000080001719)),
                          vcreate_u16(UINT64_C(0x0000000042480067)));
      arg2 = vcombine_u16(vcreate_u16(UINT64_C(0xffff7fffd9fd7fff)),
                          vcreate_u16(UINT64_C(0x7fff6c5f0000ffff)));
      clear_neon_saturated();
      //  Expect: "result" = 7fff0000ffffd9fd0000424851a380006c5fffff7fff7fff0000006700001719
      result = vuzpq_u16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result.val[0]), 0);
         exp = UINT64_C(0x0000006700001719);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result.val[0]), 1);
         exp = UINT64_C(0x6c5fffff7fff7fff);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result.val[1]), 0);
         exp = UINT64_C(0x0000424851a38000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u16(result.val[1]), 1);
         exp = UINT64_C(0x7fff0000ffffd9fd);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_3343() {

{
   {
      uint32x4_t arg1;
      uint32x4_t arg2;
      uint32x4x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"uzp\", fnname = \"vuzpq_u32\", rettype = \"uint32x4x2_t\", argtypes = \"[uint32x4_t,uint32x4_t]\", vals = [VectorVal [IntegerVal 2147450880,IntegerVal 487391232,IntegerVal 32767,IntegerVal 2147483647],VectorVal [IntegerVal 4294901760,IntegerVal 0,IntegerVal 3486220288,IntegerVal 1283620863]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_u32(vcreate_u32(UINT64_C(0x1d0d00007fff8000)),
                          vcreate_u32(UINT64_C(0x7fffffff00007fff)));
      arg2 = vcombine_u32(vcreate_u32(UINT64_C(0x00000000ffff0000)),
                          vcreate_u32(UINT64_C(0x4c827fffcfcb8000)));
      clear_neon_saturated();
      //  Expect: "result" = 4c827fff000000007fffffff1d0d0000cfcb8000ffff000000007fff7fff8000
      result = vuzpq_u32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result.val[0]), 0);
         exp = UINT64_C(0x00007fff7fff8000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result.val[0]), 1);
         exp = UINT64_C(0xcfcb8000ffff0000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result.val[1]), 0);
         exp = UINT64_C(0x7fffffff1d0d0000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_u32(result.val[1]), 1);
         exp = UINT64_C(0x4c827fff00000000);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_3344() {

{
   {
      poly8x16_t arg1;
      poly8x16_t arg2;
      poly8x16x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"uzp\", fnname = \"vuzpq_p8\", rettype = \"poly8x16x2_t\", argtypes = \"[poly8x16_t,poly8x16_t]\", vals = [VectorVal [PolyVal [1,0,1,1,1,1,0,0],PolyVal [0,1,1,1,0,0,1,1],PolyVal [0,1,0,1,1,1,1,0],PolyVal [1,1,0,0,1,1,0,1],PolyVal [0,1,1,1,1,0,1,0],PolyVal [0,1,0,0,1,1,0,0],PolyVal [1,1,1,0,1,0,1,0],PolyVal [0,0,1,0,1,0,0,0],PolyVal [1,0,0,0,0,1,0,0],PolyVal [0,1,1,0,1,0,1,1],PolyVal [0,0,1,1,1,0,0,0],PolyVal [1,1,0,1,1,1,0,1],PolyVal [1,0,0,0,0,0,1,0],PolyVal [1,0,0,0,1,0,1,0],PolyVal [0,0,1,0,0,0,1,0],PolyVal [0,0,1,0,0,1,0,1]],VectorVal [PolyVal [1,1,0,1,1,0,0,0],PolyVal [0,1,0,0,0,0,1,1],PolyVal [1,0,0,1,0,1,0,1],PolyVal [1,1,0,0,1,1,1,0],PolyVal [1,0,1,0,1,1,1,1],PolyVal [0,1,0,0,1,1,0,0],PolyVal [0,1,1,1,1,0,0,1],PolyVal [1,1,0,1,0,0,0,0],PolyVal [1,0,1,0,0,1,0,0],PolyVal [0,0,0,1,0,1,1,0],PolyVal [0,1,1,1,0,1,1,1],PolyVal [1,0,1,0,0,0,0,0],PolyVal [0,1,1,1,0,1,1,0],PolyVal [0,1,1,0,0,0,0,0],PolyVal [1,0,0,0,0,0,1,1],PolyVal [1,1,0,0,0,1,0,1]]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_p8(vcreate_p8(UINT64_C(0x1457325eb37ace3d)),
                         vcreate_p8(UINT64_C(0xa4445141bb1cd621)));
      arg2 = vcombine_p8(vcreate_p8(UINT64_C(0x0b9e32f573a9c21b)),
                         vcreate_p8(UINT64_C(0xa3c1066e05ee6825)));
      clear_neon_saturated();
      //  Expect: "result" = a30605680b3273c2a451bbd61432b3cec16eee259ef5a91b44411c21575e7a3d
      result = vuzpq_p8(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p8(result.val[0]), 0);
         exp = UINT64_C(0x44411c21575e7a3d);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p8(result.val[0]), 1);
         exp = UINT64_C(0xc16eee259ef5a91b);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p8(result.val[1]), 0);
         exp = UINT64_C(0xa451bbd61432b3ce);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p8(result.val[1]), 1);
         exp = UINT64_C(0xa30605680b3273c2);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_3345() {

{
   {
      poly16x8_t arg1;
      poly16x8_t arg2;
      poly16x8x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"uzp\", fnname = \"vuzpq_p16\", rettype = \"poly16x8x2_t\", argtypes = \"[poly16x8_t,poly16x8_t]\", vals = [VectorVal [PolyVal [1,1,1,1,0,0,1,0,0,0,0,1,0,1,0,1],PolyVal [1,1,0,1,1,1,1,0,1,0,1,0,0,1,1,1],PolyVal [0,0,1,0,1,1,1,1,1,0,1,1,1,0,1,0],PolyVal [1,1,0,1,0,1,0,1,1,1,0,0,1,0,1,1],PolyVal [1,0,1,0,0,1,0,1,0,0,0,1,1,1,0,0],PolyVal [0,0,0,0,0,1,1,1,0,0,0,1,0,1,0,0],PolyVal [1,0,0,0,1,0,0,1,0,1,0,0,1,0,1,1],PolyVal [0,1,1,0,0,1,0,0,1,0,1,1,0,0,1,1]],VectorVal [PolyVal [1,0,0,1,1,1,0,1,0,1,0,1,0,0,0,1],PolyVal [1,0,1,1,0,1,0,1,1,0,1,1,1,0,1,1],PolyVal [1,1,1,0,0,1,0,0,0,0,1,0,1,1,1,0],PolyVal [1,1,1,1,0,1,1,0,0,0,0,0,1,1,0,0],PolyVal [0,1,1,0,1,1,1,1,0,0,1,0,0,1,0,0],PolyVal [1,0,1,1,0,0,1,0,1,0,1,0,1,0,1,0],PolyVal [0,1,0,0,1,1,1,1,1,0,1,1,0,0,0,0],PolyVal [0,1,1,1,0,1,1,1,0,0,1,0,0,1,0,0]]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_p16(vcreate_p16(UINT64_C(0xd3ab5df4e57ba84f)),
                          vcreate_p16(UINT64_C(0xcd26d29128e038a5)));
      arg2 = vcombine_p16(vcreate_p16(UINT64_C(0x306f7427ddad8ab9)),
                          vcreate_p16(UINT64_C(0x24ee0df2554d24f6)));
      clear_neon_saturated();
      //  Expect: "result" = 24ee554d306fddadcd2628e0d3abe57b0df224f674278ab9d29138a55df4a84f
      result = vuzpq_p16(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p16(result.val[0]), 0);
         exp = UINT64_C(0xd29138a55df4a84f);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p16(result.val[0]), 1);
         exp = UINT64_C(0x0df224f674278ab9);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 0 High part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p16(result.val[1]), 0);
         exp = UINT64_C(0xcd2628e0d3abe57b);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 Low part ",
                      exp,
                      got);
            }
      }
      {
         uint64_t got;
         uint64_t exp;
         got = vgetq_lane_u64(vreinterpretq_u64_p16(result.val[1]), 1);
         exp = UINT64_C(0x24ee554d306fddad);
         if((exp != got))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                      "   Vector 1 High part ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_3346() {

{
   {
      float32x4_t arg1;
      float32x4_t arg2;
      float32x4x2_t result;
      char* str1 = "ReproInfo2 {semantics = \"uzp\", fnname = \"vuzpq_f32\", rettype = \"float32x4x2_t\", argtypes = \"[float32x4_t,float32x4_t]\", vals = [VectorVal [FloatVal 0.9535794258117676,FloatVal 0.40865665674209595,FloatVal 0.5157067775726318,FloatVal 0.7190629243850708],VectorVal [FloatVal 0.5040917992591858,FloatVal 0.7561329007148743,FloatVal 0.5837388038635254,FloatVal 0.867925763130188]], start_saturated = False}";
      int reported = 0;
      arg1 = vcombine_f32(vcreate_f32(UINT64_C(0x3ed13b723f741dc8)),
                          vcreate_f32(UINT64_C(0x3f3814823f04055c)));
      arg2 = vcombine_f32(vcreate_f32(UINT64_C(0x3f4191ed3f010c29)),
                          vcreate_f32(UINT64_C(0x3f5e30623f156fe8)));
      clear_neon_saturated();
      //  Expect: "result" = 3f5e30623f4191ed3f3814823ed13b723f156fe83f010c293f04055c3f741dc8
      result = vuzpq_f32(arg1, arg2);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result.val[0], 0);
         exp = ((float32_t) 0.9535794258117676);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 0 ",
                      exp,
                      got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result.val[0], 1);
         exp = ((float32_t) 0.5157067775726318);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 1 ",
                      exp,
                      got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result.val[0], 2);
         exp = ((float32_t) 0.5040917992591858);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 2 ",
                      exp,
                      got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result.val[0], 3);
         exp = ((float32_t) 0.5837388038635254);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 0 Lane 3 ",
                      exp,
                      got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result.val[1], 0);
         exp = ((float32_t) 0.40865665674209595);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 0 ",
                      exp,
                      got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result.val[1], 1);
         exp = ((float32_t) 0.7190629243850708);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 1 ",
                      exp,
                      got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result.val[1], 2);
         exp = ((float32_t) 0.7561329007148743);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 2 ",
                      exp,
                      got);
            }
      }
      {
         float32_t got;
         float32_t exp;
         got = vgetq_lane_f32(result.val[1], 3);
         exp = ((float32_t) 0.867925763130188);
         if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
            {
               if(reported == 0)
                  {
                     printf("%s\n", str1);
                     reported = 1;
                  }
               failed = 1;
               printf("%sExpected: %f Got: %f\n",
                      "   Vector 1 Lane 3 ",
                      exp,
                      got);
            }
      }
   }
}
}
void dotests_3347() {

{
   {
      int32x2_t arg1;
      int32_t result;
      char* str1 = "ReproInfo2 {semantics = \"addv\", fnname = \"vaddv_s32\", rettype = \"int32_t\", argtypes = \"[int32x2_t]\", vals = [VectorVal [IntegerVal (-2147450881),IntegerVal (-924286977)]], start_saturated = False}";
      int reported = 0;
      int32_t got;
      int32_t exp;
      arg1 = vcreate_s32(UINT64_C(0xc8e87fff80007fff));
      clear_neon_saturated();
      //  Expect: "result" = 48e8fffe
      result = vaddv_s32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = 1223229438;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIi32 " Got: %" PRIi32 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_3348() {

{
   {
      uint32x2_t arg1;
      uint32_t result;
      char* str1 = "ReproInfo2 {semantics = \"addv\", fnname = \"vaddv_u32\", rettype = \"uint32_t\", argtypes = \"[uint32x2_t]\", vals = [VectorVal [IntegerVal 2147450880,IntegerVal 2147516415]], start_saturated = False}";
      int reported = 0;
      uint32_t got;
      uint32_t exp;
      arg1 = vcreate_u32(UINT64_C(0x80007fff7fff8000));
      clear_neon_saturated();
      //  Expect: "result" = ffffffff
      result = vaddv_u32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = 4294967295U;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIu32 " Got: %" PRIu32 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_3349() {

{
   {
      int64x2_t arg1;
      int64_t result;
      char* str1 = "ReproInfo2 {semantics = \"addv\", fnname = \"vaddvq_s64\", rettype = \"int64_t\", argtypes = \"[int64x2_t]\", vals = [VectorVal [IntegerVal 140741783257088,IntegerVal (-8047791798770267055)]], start_saturated = False}";
      int reported = 0;
      int64_t got;
      int64_t exp;
      arg1 = vcombine_s64(vcreate_s64(UINT64_C(0x00008000ffff0000)),
                          vcreate_s64(UINT64_C(0x90507fff7fff0c51)));
      clear_neon_saturated();
      //  Expect: "result" = 905100007ffe0c51
      result = vaddvq_s64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = INT64_C(-8047651056987009967);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIi64 " Got: %" PRIi64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_3350() {

{
   {
      uint64x2_t arg1;
      uint64_t result;
      char* str1 = "ReproInfo2 {semantics = \"addv\", fnname = \"vaddvq_u64\", rettype = \"uint64_t\", argtypes = \"[uint64x2_t]\", vals = [VectorVal [IntegerVal 18065626950948378916,IntegerVal 140733193388032]], start_saturated = False}";
      int reported = 0;
      uint64_t got;
      uint64_t exp;
      arg1 = vcombine_u64(vcreate_u64(UINT64_C(0xfab5ffff00005924)),
                          vcreate_u64(UINT64_C(0x00007fff00000000)));
      clear_neon_saturated();
      //  Expect: "result" = fab67ffe00005924
      result = vaddvq_u64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = UINT64_C(0xfab67ffe00005924);
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %016" PRIx64 " Got: %016" PRIx64 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_3351() {

{
   {
      float64x2_t arg1;
      float64_t result;
      char* str1 = "ReproInfo2 {semantics = \"addv\", fnname = \"vaddvq_f64\", rettype = \"float64_t\", argtypes = \"[float64x2_t]\", vals = [VectorVal [FloatVal 0.7446840760189667,FloatVal 0.9522285102945328]], start_saturated = False}";
      int reported = 0;
      float64_t got;
      float64_t exp;
      arg1 = vcombine_f64(vcreate_f64(UINT64_C(0x3fe7d473b30b4f61)),
                          vcreate_f64(UINT64_C(0x3fee78a7ecc11509)));
      clear_neon_saturated();
      //  Expect: "result" = 3ffb268dcfe63235
      result = vaddvq_f64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = 1.6969125863134995;
      if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %f Got: %f\n", "   ", exp, got);
         }
   }
}
}
void dotests_3352() {

{
   {
      float32x2_t arg1;
      float32_t result;
      char* str1 = "ReproInfo2 {semantics = \"addv\", fnname = \"vaddv_f32\", rettype = \"float32_t\", argtypes = \"[float32x2_t]\", vals = [VectorVal [FloatVal 3.1695544719696045e-2,FloatVal 0.26221680641174316]], start_saturated = False}";
      int reported = 0;
      float32_t got;
      float32_t exp;
      arg1 = vcreate_f32(UINT64_C(0x3e8641483d01d330));
      clear_neon_saturated();
      //  Expect: "result" = 3e967bae
      result = vaddv_f32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = ((float32_t) 0.2939123511314392);
      if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %f Got: %f\n", "   ", exp, got);
         }
   }
}
}
void dotests_3353() {

{
   {
      float32x4_t arg1;
      float32_t result;
      char* str1 = "ReproInfo2 {semantics = \"addv\", fnname = \"vaddvq_f32\", rettype = \"float32_t\", argtypes = \"[float32x4_t]\", vals = [VectorVal [FloatVal 3.90891432762146e-2,FloatVal 0.7387893795967102,FloatVal 7.691895961761475e-2,FloatVal 0.19967317581176758]], start_saturated = False}";
      int reported = 0;
      float32_t got;
      float32_t exp;
      arg1 = vcombine_f32(vcreate_f32(UINT64_C(0x3f3d214d3d201bf0)),
                          vcreate_f32(UINT64_C(0x3e4c77203d9d87b0)));
      clear_neon_saturated();
      //  Expect: "result" = 3f86f8e5
      result = vaddvq_f32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = ((float32_t) 1.0544706583023071);
      if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %f Got: %f\n", "   ", exp, got);
         }
   }
}
}
void dotests_3354() {

{
   {
      int32x2_t arg1;
      int32_t result;
      char* str1 = "ReproInfo2 {semantics = \"maxv\", fnname = \"vmaxv_s32\", rettype = \"int32_t\", argtypes = \"[int32x2_t]\", vals = [VectorVal [IntegerVal 2147483647,IntegerVal 1852728328]], start_saturated = False}";
      int reported = 0;
      int32_t got;
      int32_t exp;
      arg1 = vcreate_s32(UINT64_C(0x6e6e64087fffffff));
      clear_neon_saturated();
      //  Expect: "result" = 7fffffff
      result = vmaxv_s32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = 2147483647;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIi32 " Got: %" PRIi32 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_3355() {

{
   {
      uint32x2_t arg1;
      uint32_t result;
      char* str1 = "ReproInfo2 {semantics = \"maxv\", fnname = \"vmaxv_u32\", rettype = \"uint32_t\", argtypes = \"[uint32x2_t]\", vals = [VectorVal [IntegerVal 4294934527,IntegerVal 0]], start_saturated = False}";
      int reported = 0;
      uint32_t got;
      uint32_t exp;
      arg1 = vcreate_u32(UINT64_C(0x00000000ffff7fff));
      clear_neon_saturated();
      //  Expect: "result" = ffff7fff
      result = vmaxv_u32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = 4294934527U;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIu32 " Got: %" PRIu32 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_3356() {

{
   {
      float32x2_t arg1;
      float32_t result;
      char* str1 = "ReproInfo2 {semantics = \"maxv\", fnname = \"vmaxv_f32\", rettype = \"float32_t\", argtypes = \"[float32x2_t]\", vals = [VectorVal [FloatVal 0.13458478450775146,FloatVal 2.5257110595703125e-2]], start_saturated = False}";
      int reported = 0;
      float32_t got;
      float32_t exp;
      arg1 = vcreate_f32(UINT64_C(0x3ccee8003e09d098));
      clear_neon_saturated();
      //  Expect: "result" = 3e09d098
      result = vmaxv_f32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = ((float32_t) 0.13458478450775146);
      if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %f Got: %f\n", "   ", exp, got);
         }
   }
}
}
void dotests_3357() {

{
   {
      float64x2_t arg1;
      float64_t result;
      char* str1 = "ReproInfo2 {semantics = \"maxv\", fnname = \"vmaxvq_f64\", rettype = \"float64_t\", argtypes = \"[float64x2_t]\", vals = [VectorVal [FloatVal 0.5303396508508353,FloatVal 0.38291508241609673]], start_saturated = False}";
      int reported = 0;
      float64_t got;
      float64_t exp;
      arg1 = vcombine_f64(vcreate_f64(UINT64_C(0x3fe0f88adc05a50a)),
                          vcreate_f64(UINT64_C(0x3fd881ae4307d370)));
      clear_neon_saturated();
      //  Expect: "result" = 3fe0f88adc05a50a
      result = vmaxvq_f64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = 0.5303396508508353;
      if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %f Got: %f\n", "   ", exp, got);
         }
   }
}
}
void dotests_3358() {

{
   {
      float64x2_t arg1;
      float64_t result;
      char* str1 = "ReproInfo2 {semantics = \"maxvnm\", fnname = \"vmaxnmvq_f64\", rettype = \"float64_t\", argtypes = \"[float64x2_t]\", vals = [VectorVal [FloatVal 0.35889865601487436,FloatVal 0.25775360027107463]], start_saturated = False}";
      int reported = 0;
      float64_t got;
      float64_t exp;
      arg1 = vcombine_f64(vcreate_f64(UINT64_C(0x3fd6f832118a6220)),
                          vcreate_f64(UINT64_C(0x3fd07f08f4e5cb1e)));
      clear_neon_saturated();
      //  Expect: "result" = 3fd6f832118a6220
      result = vmaxnmvq_f64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = 0.35889865601487436;
      if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %f Got: %f\n", "   ", exp, got);
         }
   }
}
}
void dotests_3359() {

{
   {
      float32x2_t arg1;
      float32_t result;
      char* str1 = "ReproInfo2 {semantics = \"maxvnm\", fnname = \"vmaxnmv_f32\", rettype = \"float32_t\", argtypes = \"[float32x2_t]\", vals = [VectorVal [FloatVal 0.3117748498916626,FloatVal 0.9137977957725525]], start_saturated = True}";
      int reported = 0;
      float32_t got;
      float32_t exp;
      arg1 = vcreate_f32(UINT64_C(0x3f69eea73e9fa0f4));
      set_neon_saturated();
      //  Expect: "result" = 3f69eea7
      result = vmaxnmv_f32(arg1);
      if((test_saturation(get_neon_saturated_inv())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Didn't get expected saturation");
         }
      got = result;
      exp = ((float32_t) 0.9137977957725525);
      if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %f Got: %f\n", "   ", exp, got);
         }
   }
}
}
void dotests_3360() {

{
   {
      int32x2_t arg1;
      int32_t result;
      char* str1 = "ReproInfo2 {semantics = \"minv\", fnname = \"vminv_s32\", rettype = \"int32_t\", argtypes = \"[int32x2_t]\", vals = [VectorVal [IntegerVal (-1879670785),IntegerVal (-1)]], start_saturated = False}";
      int reported = 0;
      int32_t got;
      int32_t exp;
      arg1 = vcreate_s32(UINT64_C(0xffffffff8ff67fff));
      clear_neon_saturated();
      //  Expect: "result" = 8ff67fff
      result = vminv_s32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = -1879670785;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIi32 " Got: %" PRIi32 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_3361() {

{
   {
      uint32x2_t arg1;
      uint32_t result;
      char* str1 = "ReproInfo2 {semantics = \"minv\", fnname = \"vminv_u32\", rettype = \"uint32_t\", argtypes = \"[uint32x2_t]\", vals = [VectorVal [IntegerVal 3635347456,IntegerVal 2147483647]], start_saturated = False}";
      int reported = 0;
      uint32_t got;
      uint32_t exp;
      arg1 = vcreate_u32(UINT64_C(0x7fffffffd8af0000));
      clear_neon_saturated();
      //  Expect: "result" = 7fffffff
      result = vminv_u32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = 2147483647U;
      if((exp != got))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %" PRIu32 " Got: %" PRIu32 "\n",
                   "   ",
                   exp,
                   got);
         }
   }
}
}
void dotests_3362() {

{
   {
      float32x2_t arg1;
      float32_t result;
      char* str1 = "ReproInfo2 {semantics = \"minv\", fnname = \"vminv_f32\", rettype = \"float32_t\", argtypes = \"[float32x2_t]\", vals = [VectorVal [FloatVal 0.6508356332778931,FloatVal 0.34391075372695923]], start_saturated = False}";
      int reported = 0;
      float32_t got;
      float32_t exp;
      arg1 = vcreate_f32(UINT64_C(0x3eb015123f269d2a));
      clear_neon_saturated();
      //  Expect: "result" = 3eb01512
      result = vminv_f32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = ((float32_t) 0.34391075372695923);
      if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %f Got: %f\n", "   ", exp, got);
         }
   }
}
}
void dotests_3363() {

{
   {
      float64x2_t arg1;
      float64_t result;
      char* str1 = "ReproInfo2 {semantics = \"minv\", fnname = \"vminvq_f64\", rettype = \"float64_t\", argtypes = \"[float64x2_t]\", vals = [VectorVal [FloatVal 0.843918749150233,FloatVal 0.6861413353349259]], start_saturated = False}";
      int reported = 0;
      float64_t got;
      float64_t exp;
      arg1 = vcombine_f64(vcreate_f64(UINT64_C(0x3feb0161e4829b79)),
                          vcreate_f64(UINT64_C(0x3fe5f4deac765016)));
      clear_neon_saturated();
      //  Expect: "result" = 3fe5f4deac765016
      result = vminvq_f64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = 0.6861413353349259;
      if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %f Got: %f\n", "   ", exp, got);
         }
   }
}
}
void dotests_3364() {

{
   {
      float64x2_t arg1;
      float64_t result;
      char* str1 = "ReproInfo2 {semantics = \"minvnm\", fnname = \"vminnmvq_f64\", rettype = \"float64_t\", argtypes = \"[float64x2_t]\", vals = [VectorVal [FloatVal 0.6784386596872218,FloatVal 0.7929936716151004]], start_saturated = False}";
      int reported = 0;
      float64_t got;
      float64_t exp;
      arg1 = vcombine_f64(vcreate_f64(UINT64_C(0x3fe5b5c4fdf65bae)),
                          vcreate_f64(UINT64_C(0x3fe9603443b0b2bf)));
      clear_neon_saturated();
      //  Expect: "result" = 3fe5b5c4fdf65bae
      result = vminnmvq_f64(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = 0.6784386596872218;
      if(((((exp / got) < 0.999) || ((exp / got) > 1.001)) && (((exp - got) < -1.0e-4) || ((exp - got) > 1.0e-4))))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %f Got: %f\n", "   ", exp, got);
         }
   }
}
}
void dotests_3365() {

{
   {
      float32x2_t arg1;
      float32_t result;
      char* str1 = "ReproInfo2 {semantics = \"minvnm\", fnname = \"vminnmv_f32\", rettype = \"float32_t\", argtypes = \"[float32x2_t]\", vals = [VectorVal [FloatVal 0.47329944372177124,FloatVal 0.8240448832511902]], start_saturated = False}";
      int reported = 0;
      float32_t got;
      float32_t exp;
      arg1 = vcreate_f32(UINT64_C(0x3f52f49b3ef2544e));
      clear_neon_saturated();
      //  Expect: "result" = 3ef2544e
      result = vminnmv_f32(arg1);
      if((test_saturation(get_neon_saturated())))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%s\n", "   Got unexpected saturation");
         }
      got = result;
      exp = ((float32_t) 0.47329944372177124);
      if(((((exp / got) < ((float32_t) 0.999)) || ((exp / got) > ((float32_t) 1.001))) && (((exp - got) < ((float32_t) -1.0e-4)) || ((exp - got) > ((float32_t) 1.0e-4)))))
         {
            if(reported == 0)
               {
                  printf("%s\n", str1);
                  reported = 1;
               }
            failed = 1;
            printf("%sExpected: %f Got: %f\n", "   ", exp, got);
         }
   }
}
}
int main() {
printf("Starting tests now\n");
dotests_1();
dotests_2();
dotests_3();
dotests_4();
dotests_5();
dotests_6();
dotests_7();
dotests_8();
dotests_9();
dotests_10();
dotests_11();
dotests_12();
dotests_13();
dotests_14();
dotests_15();
dotests_16();
dotests_17();
dotests_18();
dotests_19();
dotests_20();
dotests_21();
dotests_22();
dotests_23();
dotests_24();
dotests_25();
dotests_26();
dotests_27();
dotests_28();
dotests_29();
dotests_30();
dotests_31();
dotests_32();
dotests_33();
dotests_34();
dotests_35();
dotests_36();
dotests_37();
dotests_38();
dotests_39();
dotests_40();
dotests_41();
dotests_42();
dotests_43();
dotests_44();
dotests_45();
dotests_46();
dotests_47();
dotests_48();
dotests_49();
dotests_50();
dotests_51();
dotests_52();
dotests_53();
dotests_54();
dotests_55();
dotests_56();
dotests_57();
dotests_58();
dotests_59();
dotests_60();
dotests_61();
dotests_62();
dotests_63();
dotests_64();
dotests_65();
dotests_66();
dotests_67();
dotests_68();
dotests_69();
dotests_70();
dotests_71();
dotests_72();
dotests_73();
dotests_74();
dotests_75();
dotests_76();
dotests_77();
dotests_78();
dotests_79();
dotests_80();
dotests_81();
dotests_82();
dotests_83();
dotests_84();
dotests_85();
dotests_86();
dotests_87();
dotests_88();
dotests_89();
dotests_90();
dotests_91();
dotests_92();
dotests_93();
dotests_94();
dotests_95();
dotests_96();
dotests_97();
dotests_98();
dotests_99();
dotests_100();
dotests_101();
dotests_102();
dotests_103();
dotests_104();
dotests_105();
dotests_106();
dotests_107();
dotests_108();
dotests_109();
dotests_110();
dotests_111();
dotests_112();
dotests_113();
dotests_114();
dotests_115();
dotests_116();
dotests_117();
dotests_118();
dotests_119();
dotests_120();
dotests_121();
dotests_122();
dotests_123();
dotests_124();
dotests_125();
dotests_126();
dotests_127();
dotests_128();
dotests_129();
dotests_130();
dotests_131();
dotests_132();
dotests_133();
dotests_134();
dotests_135();
dotests_136();
dotests_137();
dotests_138();
dotests_139();
dotests_140();
dotests_141();
dotests_142();
dotests_143();
dotests_144();
dotests_145();
dotests_146();
dotests_147();
dotests_148();
dotests_149();
dotests_150();
dotests_151();
dotests_152();
dotests_153();
dotests_154();
dotests_155();
dotests_156();
dotests_157();
dotests_158();
dotests_159();
dotests_160();
dotests_161();
dotests_162();
dotests_163();
dotests_164();
dotests_165();
dotests_166();
dotests_167();
dotests_168();
dotests_169();
dotests_170();
dotests_171();
dotests_172();
dotests_173();
dotests_174();
dotests_175();
dotests_176();
dotests_177();
dotests_178();
dotests_179();
dotests_180();
dotests_181();
dotests_182();
dotests_183();
dotests_184();
dotests_185();
dotests_186();
dotests_187();
dotests_188();
dotests_189();
dotests_190();
dotests_191();
dotests_192();
dotests_193();
dotests_194();
dotests_195();
dotests_196();
dotests_197();
dotests_198();
dotests_199();
dotests_200();
dotests_201();
dotests_202();
dotests_203();
dotests_204();
dotests_205();
dotests_206();
dotests_207();
dotests_208();
dotests_209();
dotests_210();
dotests_211();
dotests_212();
dotests_213();
dotests_214();
dotests_215();
dotests_216();
dotests_217();
dotests_218();
dotests_219();
dotests_220();
dotests_221();
dotests_222();
dotests_223();
dotests_224();
dotests_225();
dotests_226();
dotests_227();
dotests_228();
dotests_229();
dotests_230();
dotests_231();
dotests_232();
dotests_233();
dotests_234();
dotests_235();
dotests_236();
dotests_237();
dotests_238();
dotests_239();
dotests_240();
dotests_241();
dotests_242();
dotests_243();
dotests_244();
dotests_245();
dotests_246();
dotests_247();
dotests_248();
dotests_249();
dotests_250();
dotests_251();
dotests_252();
dotests_253();
dotests_254();
dotests_255();
dotests_256();
dotests_257();
dotests_258();
dotests_259();
dotests_260();
dotests_261();
dotests_262();
dotests_263();
dotests_264();
dotests_265();
dotests_266();
dotests_267();
dotests_268();
dotests_269();
dotests_270();
dotests_271();
dotests_272();
dotests_273();
dotests_274();
dotests_275();
dotests_276();
dotests_277();
dotests_278();
dotests_279();
dotests_280();
dotests_281();
dotests_282();
dotests_283();
dotests_284();
dotests_285();
dotests_286();
dotests_287();
dotests_288();
dotests_289();
dotests_290();
dotests_291();
dotests_292();
dotests_293();
dotests_294();
dotests_295();
dotests_296();
dotests_297();
dotests_298();
dotests_299();
dotests_300();
dotests_301();
dotests_302();
dotests_303();
dotests_304();
dotests_305();
dotests_306();
dotests_307();
dotests_308();
dotests_309();
dotests_310();
dotests_311();
dotests_312();
dotests_313();
dotests_314();
dotests_315();
dotests_316();
dotests_317();
dotests_318();
dotests_319();
dotests_320();
dotests_321();
dotests_322();
dotests_323();
dotests_324();
dotests_325();
dotests_326();
dotests_327();
dotests_328();
dotests_329();
dotests_330();
dotests_331();
dotests_332();
dotests_333();
dotests_334();
dotests_335();
dotests_336();
dotests_337();
dotests_338();
dotests_339();
dotests_340();
dotests_341();
dotests_342();
dotests_343();
dotests_344();
dotests_345();
dotests_346();
dotests_347();
dotests_348();
dotests_349();
dotests_350();
dotests_351();
dotests_352();
dotests_353();
dotests_354();
dotests_355();
dotests_356();
dotests_357();
dotests_358();
dotests_359();
dotests_360();
dotests_361();
dotests_362();
dotests_363();
dotests_364();
dotests_365();
dotests_366();
dotests_367();
dotests_368();
dotests_369();
dotests_370();
dotests_371();
dotests_372();
dotests_373();
dotests_374();
dotests_375();
dotests_376();
dotests_377();
dotests_378();
dotests_379();
dotests_380();
dotests_381();
dotests_382();
dotests_383();
dotests_384();
dotests_385();
dotests_386();
dotests_387();
dotests_388();
dotests_389();
dotests_390();
dotests_391();
dotests_392();
dotests_393();
dotests_394();
dotests_395();
dotests_396();
dotests_397();
dotests_398();
dotests_399();
dotests_400();
dotests_401();
dotests_402();
dotests_403();
dotests_404();
dotests_405();
dotests_406();
dotests_407();
dotests_408();
dotests_409();
dotests_410();
dotests_411();
dotests_412();
dotests_413();
dotests_414();
dotests_415();
dotests_416();
dotests_417();
dotests_418();
dotests_419();
dotests_420();
dotests_421();
dotests_422();
dotests_423();
dotests_424();
dotests_425();
dotests_426();
dotests_427();
dotests_428();
dotests_429();
dotests_430();
dotests_431();
dotests_432();
dotests_433();
dotests_434();
dotests_435();
dotests_436();
dotests_437();
dotests_438();
dotests_439();
dotests_440();
dotests_441();
dotests_442();
dotests_443();
dotests_444();
dotests_445();
dotests_446();
dotests_447();
dotests_448();
dotests_449();
dotests_450();
dotests_451();
dotests_452();
dotests_453();
dotests_454();
dotests_455();
dotests_456();
dotests_457();
dotests_458();
dotests_459();
dotests_460();
dotests_461();
dotests_462();
dotests_463();
dotests_464();
dotests_465();
dotests_466();
dotests_467();
dotests_468();
dotests_469();
dotests_470();
dotests_471();
dotests_472();
dotests_473();
dotests_474();
dotests_475();
dotests_476();
dotests_477();
dotests_478();
dotests_479();
dotests_480();
dotests_481();
dotests_482();
dotests_483();
dotests_484();
dotests_485();
dotests_486();
dotests_487();
dotests_488();
dotests_489();
dotests_490();
dotests_491();
dotests_492();
dotests_493();
dotests_494();
dotests_495();
dotests_496();
dotests_497();
dotests_498();
dotests_499();
dotests_500();
dotests_501();
dotests_502();
dotests_503();
dotests_504();
dotests_505();
dotests_506();
dotests_507();
dotests_508();
dotests_509();
dotests_510();
dotests_511();
dotests_512();
dotests_513();
dotests_514();
dotests_515();
dotests_516();
dotests_517();
dotests_518();
dotests_519();
dotests_520();
dotests_521();
dotests_522();
dotests_523();
dotests_524();
dotests_525();
dotests_526();
dotests_527();
dotests_528();
dotests_529();
dotests_530();
dotests_531();
dotests_532();
dotests_533();
dotests_534();
dotests_535();
dotests_536();
dotests_537();
dotests_538();
dotests_539();
dotests_540();
dotests_541();
dotests_542();
dotests_543();
dotests_544();
dotests_545();
dotests_546();
dotests_547();
dotests_548();
dotests_549();
dotests_550();
dotests_551();
dotests_552();
dotests_553();
dotests_554();
dotests_555();
dotests_556();
dotests_557();
dotests_558();
dotests_559();
dotests_560();
dotests_561();
dotests_562();
dotests_563();
dotests_564();
dotests_565();
dotests_566();
dotests_567();
dotests_568();
dotests_569();
dotests_570();
dotests_571();
dotests_572();
dotests_573();
dotests_574();
dotests_575();
dotests_576();
dotests_577();
dotests_578();
dotests_579();
dotests_580();
dotests_581();
dotests_582();
dotests_583();
dotests_584();
dotests_585();
dotests_586();
dotests_587();
dotests_588();
dotests_589();
dotests_590();
dotests_591();
dotests_592();
dotests_593();
dotests_594();
dotests_595();
dotests_596();
dotests_597();
dotests_598();
dotests_599();
dotests_600();
dotests_601();
dotests_602();
dotests_603();
dotests_604();
dotests_605();
dotests_606();
dotests_607();
dotests_608();
dotests_609();
dotests_610();
dotests_611();
dotests_612();
dotests_613();
dotests_614();
dotests_615();
dotests_616();
dotests_617();
dotests_618();
dotests_619();
dotests_620();
dotests_621();
dotests_622();
dotests_623();
dotests_624();
dotests_625();
dotests_626();
dotests_627();
dotests_628();
dotests_629();
dotests_630();
dotests_631();
dotests_632();
dotests_633();
dotests_634();
dotests_635();
dotests_636();
dotests_637();
dotests_638();
dotests_639();
dotests_640();
dotests_641();
dotests_642();
dotests_643();
dotests_644();
dotests_645();
dotests_646();
dotests_647();
dotests_648();
dotests_649();
dotests_650();
dotests_651();
dotests_652();
dotests_653();
dotests_654();
dotests_655();
dotests_656();
dotests_657();
dotests_658();
dotests_659();
dotests_660();
dotests_661();
dotests_662();
dotests_663();
dotests_664();
dotests_665();
dotests_666();
dotests_667();
dotests_668();
dotests_669();
dotests_670();
dotests_671();
dotests_672();
dotests_673();
dotests_674();
dotests_675();
dotests_676();
dotests_677();
dotests_678();
dotests_679();
dotests_680();
dotests_681();
dotests_682();
dotests_683();
dotests_684();
dotests_685();
dotests_686();
dotests_687();
dotests_688();
dotests_689();
dotests_690();
dotests_691();
dotests_692();
dotests_693();
dotests_694();
dotests_695();
dotests_696();
dotests_697();
dotests_698();
dotests_699();
dotests_700();
dotests_701();
dotests_702();
dotests_703();
dotests_704();
dotests_705();
dotests_706();
dotests_707();
dotests_708();
dotests_709();
dotests_710();
dotests_711();
dotests_712();
dotests_713();
dotests_714();
dotests_715();
dotests_716();
dotests_717();
dotests_718();
dotests_719();
dotests_720();
dotests_721();
dotests_722();
dotests_723();
dotests_724();
dotests_725();
dotests_726();
dotests_727();
dotests_728();
dotests_729();
dotests_730();
dotests_731();
dotests_732();
dotests_733();
dotests_734();
dotests_735();
dotests_736();
dotests_737();
dotests_738();
dotests_739();
dotests_740();
dotests_741();
dotests_742();
dotests_743();
dotests_744();
dotests_745();
dotests_746();
dotests_747();
dotests_748();
dotests_749();
dotests_750();
dotests_751();
dotests_752();
dotests_753();
dotests_754();
dotests_755();
dotests_756();
dotests_757();
dotests_758();
dotests_759();
dotests_760();
dotests_761();
dotests_762();
dotests_763();
dotests_764();
dotests_765();
dotests_766();
dotests_767();
dotests_768();
dotests_769();
dotests_770();
dotests_771();
dotests_772();
dotests_773();
dotests_774();
dotests_775();
dotests_776();
dotests_777();
dotests_778();
dotests_779();
dotests_780();
dotests_781();
dotests_782();
dotests_783();
dotests_784();
dotests_785();
dotests_786();
dotests_787();
dotests_788();
dotests_789();
dotests_790();
dotests_791();
dotests_792();
dotests_793();
dotests_794();
dotests_795();
dotests_796();
dotests_797();
dotests_798();
dotests_799();
dotests_800();
dotests_801();
dotests_802();
dotests_803();
dotests_804();
dotests_805();
dotests_806();
dotests_807();
dotests_808();
dotests_809();
dotests_810();
dotests_811();
dotests_812();
dotests_813();
dotests_814();
dotests_815();
dotests_816();
dotests_817();
dotests_818();
dotests_819();
dotests_820();
dotests_821();
dotests_822();
dotests_823();
dotests_824();
dotests_825();
dotests_826();
dotests_827();
dotests_828();
dotests_829();
dotests_830();
dotests_831();
dotests_832();
dotests_833();
dotests_834();
dotests_835();
dotests_836();
dotests_837();
dotests_838();
dotests_839();
dotests_840();
dotests_841();
dotests_842();
dotests_843();
dotests_844();
dotests_845();
dotests_846();
dotests_847();
dotests_848();
dotests_849();
dotests_850();
dotests_851();
dotests_852();
dotests_853();
dotests_854();
dotests_855();
dotests_856();
dotests_857();
dotests_858();
dotests_859();
dotests_860();
dotests_861();
dotests_862();
dotests_863();
dotests_864();
dotests_865();
dotests_866();
dotests_867();
dotests_868();
dotests_869();
dotests_870();
dotests_871();
dotests_872();
dotests_873();
dotests_874();
dotests_875();
dotests_876();
dotests_877();
dotests_878();
dotests_879();
dotests_880();
dotests_881();
dotests_882();
dotests_883();
dotests_884();
dotests_885();
dotests_886();
dotests_887();
dotests_888();
dotests_889();
dotests_890();
dotests_891();
dotests_892();
dotests_893();
dotests_894();
dotests_895();
dotests_896();
dotests_897();
dotests_898();
dotests_899();
dotests_900();
dotests_901();
dotests_902();
dotests_903();
dotests_904();
dotests_905();
dotests_906();
dotests_907();
dotests_908();
dotests_909();
dotests_910();
dotests_911();
dotests_912();
dotests_913();
dotests_914();
dotests_915();
dotests_916();
dotests_917();
dotests_918();
dotests_919();
dotests_920();
dotests_921();
dotests_922();
dotests_923();
dotests_924();
dotests_925();
dotests_926();
dotests_927();
dotests_928();
dotests_929();
dotests_930();
dotests_931();
dotests_932();
dotests_933();
dotests_934();
dotests_935();
dotests_936();
dotests_937();
dotests_938();
dotests_939();
dotests_940();
dotests_941();
dotests_942();
dotests_943();
dotests_944();
dotests_945();
dotests_946();
dotests_947();
dotests_948();
dotests_949();
dotests_950();
dotests_951();
dotests_952();
dotests_953();
dotests_954();
dotests_955();
dotests_956();
dotests_957();
dotests_958();
dotests_959();
dotests_960();
dotests_961();
dotests_962();
dotests_963();
dotests_964();
dotests_965();
dotests_966();
dotests_967();
dotests_968();
dotests_969();
dotests_970();
dotests_971();
dotests_972();
dotests_973();
dotests_974();
dotests_975();
dotests_976();
dotests_977();
dotests_978();
dotests_979();
dotests_980();
dotests_981();
dotests_982();
dotests_983();
dotests_984();
dotests_985();
dotests_986();
dotests_987();
dotests_988();
dotests_989();
dotests_990();
dotests_991();
dotests_992();
dotests_993();
dotests_994();
dotests_995();
dotests_996();
dotests_997();
dotests_998();
dotests_999();
dotests_1000();
dotests_1001();
dotests_1002();
dotests_1003();
dotests_1004();
dotests_1005();
dotests_1006();
dotests_1007();
dotests_1008();
dotests_1009();
dotests_1010();
dotests_1011();
dotests_1012();
dotests_1013();
dotests_1014();
dotests_1015();
dotests_1016();
dotests_1017();
dotests_1018();
dotests_1019();
dotests_1020();
dotests_1021();
dotests_1022();
dotests_1023();
dotests_1024();
dotests_1025();
dotests_1026();
dotests_1027();
dotests_1028();
dotests_1029();
dotests_1030();
dotests_1031();
dotests_1032();
dotests_1033();
dotests_1034();
dotests_1035();
dotests_1036();
dotests_1037();
dotests_1038();
dotests_1039();
dotests_1040();
dotests_1041();
dotests_1042();
dotests_1043();
dotests_1044();
dotests_1045();
dotests_1046();
dotests_1047();
dotests_1048();
dotests_1049();
dotests_1050();
dotests_1051();
dotests_1052();
dotests_1053();
dotests_1054();
dotests_1055();
dotests_1056();
dotests_1057();
dotests_1058();
dotests_1059();
dotests_1060();
dotests_1061();
dotests_1062();
dotests_1063();
dotests_1064();
dotests_1065();
dotests_1066();
dotests_1067();
dotests_1068();
dotests_1069();
dotests_1070();
dotests_1071();
dotests_1072();
dotests_1073();
dotests_1074();
dotests_1075();
dotests_1076();
dotests_1077();
dotests_1078();
dotests_1079();
dotests_1080();
dotests_1081();
dotests_1082();
dotests_1083();
dotests_1084();
dotests_1085();
dotests_1086();
dotests_1087();
dotests_1088();
dotests_1089();
dotests_1090();
dotests_1091();
dotests_1092();
dotests_1093();
dotests_1094();
dotests_1095();
dotests_1096();
dotests_1097();
dotests_1098();
dotests_1099();
dotests_1100();
dotests_1101();
dotests_1102();
dotests_1103();
dotests_1104();
dotests_1105();
dotests_1106();
dotests_1107();
dotests_1108();
dotests_1109();
dotests_1110();
dotests_1111();
dotests_1112();
dotests_1113();
dotests_1114();
dotests_1115();
dotests_1116();
dotests_1117();
dotests_1118();
dotests_1119();
dotests_1120();
dotests_1121();
dotests_1122();
dotests_1123();
dotests_1124();
dotests_1125();
dotests_1126();
dotests_1127();
dotests_1128();
dotests_1129();
dotests_1130();
dotests_1131();
dotests_1132();
dotests_1133();
dotests_1134();
dotests_1135();
dotests_1136();
dotests_1137();
dotests_1138();
dotests_1139();
dotests_1140();
dotests_1141();
dotests_1142();
dotests_1143();
dotests_1144();
dotests_1145();
dotests_1146();
dotests_1147();
dotests_1148();
dotests_1149();
dotests_1150();
dotests_1151();
dotests_1152();
dotests_1153();
dotests_1154();
dotests_1155();
dotests_1156();
dotests_1157();
dotests_1158();
dotests_1159();
dotests_1160();
dotests_1161();
dotests_1162();
dotests_1163();
dotests_1164();
dotests_1165();
dotests_1166();
dotests_1167();
dotests_1168();
dotests_1169();
dotests_1170();
dotests_1171();
dotests_1172();
dotests_1173();
dotests_1174();
dotests_1175();
dotests_1176();
dotests_1177();
dotests_1178();
dotests_1179();
dotests_1180();
dotests_1181();
dotests_1182();
dotests_1183();
dotests_1184();
dotests_1185();
dotests_1186();
dotests_1187();
dotests_1188();
dotests_1189();
dotests_1190();
dotests_1191();
dotests_1192();
dotests_1193();
dotests_1194();
dotests_1195();
dotests_1196();
dotests_1197();
dotests_1198();
dotests_1199();
dotests_1200();
dotests_1201();
dotests_1202();
dotests_1203();
dotests_1204();
dotests_1205();
dotests_1206();
dotests_1207();
dotests_1208();
dotests_1209();
dotests_1210();
dotests_1211();
dotests_1212();
dotests_1213();
dotests_1214();
dotests_1215();
dotests_1216();
dotests_1217();
dotests_1218();
dotests_1219();
dotests_1220();
dotests_1221();
dotests_1222();
dotests_1223();
dotests_1224();
dotests_1225();
dotests_1226();
dotests_1227();
dotests_1228();
dotests_1229();
dotests_1230();
dotests_1231();
dotests_1232();
dotests_1233();
dotests_1234();
dotests_1235();
dotests_1236();
dotests_1237();
dotests_1238();
dotests_1239();
dotests_1240();
dotests_1241();
dotests_1242();
dotests_1243();
dotests_1244();
dotests_1245();
dotests_1246();
dotests_1247();
dotests_1248();
dotests_1249();
dotests_1250();
dotests_1251();
dotests_1252();
dotests_1253();
dotests_1254();
dotests_1255();
dotests_1256();
dotests_1257();
dotests_1258();
dotests_1259();
dotests_1260();
dotests_1261();
dotests_1262();
dotests_1263();
dotests_1264();
dotests_1265();
dotests_1266();
dotests_1267();
dotests_1268();
dotests_1269();
dotests_1270();
dotests_1271();
dotests_1272();
dotests_1273();
dotests_1274();
dotests_1275();
dotests_1276();
dotests_1277();
dotests_1278();
dotests_1279();
dotests_1280();
dotests_1281();
dotests_1282();
dotests_1283();
dotests_1284();
dotests_1285();
dotests_1286();
dotests_1287();
dotests_1288();
dotests_1289();
dotests_1290();
dotests_1291();
dotests_1292();
dotests_1293();
dotests_1294();
dotests_1295();
dotests_1296();
dotests_1297();
dotests_1298();
dotests_1299();
dotests_1300();
dotests_1301();
dotests_1302();
dotests_1303();
dotests_1304();
dotests_1305();
dotests_1306();
dotests_1307();
dotests_1308();
dotests_1309();
dotests_1310();
dotests_1311();
dotests_1312();
dotests_1313();
dotests_1314();
dotests_1315();
dotests_1316();
dotests_1317();
dotests_1318();
dotests_1319();
dotests_1320();
dotests_1321();
dotests_1322();
dotests_1323();
dotests_1324();
dotests_1325();
dotests_1326();
dotests_1327();
dotests_1328();
dotests_1329();
dotests_1330();
dotests_1331();
dotests_1332();
dotests_1333();
dotests_1334();
dotests_1335();
dotests_1336();
dotests_1337();
dotests_1338();
dotests_1339();
dotests_1340();
dotests_1341();
dotests_1342();
dotests_1343();
dotests_1344();
dotests_1345();
dotests_1346();
dotests_1347();
dotests_1348();
dotests_1349();
dotests_1350();
dotests_1351();
dotests_1352();
dotests_1353();
dotests_1354();
dotests_1355();
dotests_1356();
dotests_1357();
dotests_1358();
dotests_1359();
dotests_1360();
dotests_1361();
dotests_1362();
dotests_1363();
dotests_1364();
dotests_1365();
dotests_1366();
dotests_1367();
dotests_1368();
dotests_1369();
dotests_1370();
dotests_1371();
dotests_1372();
dotests_1373();
dotests_1374();
dotests_1375();
dotests_1376();
dotests_1377();
dotests_1378();
dotests_1379();
dotests_1380();
dotests_1381();
dotests_1382();
dotests_1383();
dotests_1384();
dotests_1385();
dotests_1386();
dotests_1387();
dotests_1388();
dotests_1389();
dotests_1390();
dotests_1391();
dotests_1392();
dotests_1393();
dotests_1394();
dotests_1395();
dotests_1396();
dotests_1397();
dotests_1398();
dotests_1399();
dotests_1400();
dotests_1401();
dotests_1402();
dotests_1403();
dotests_1404();
dotests_1405();
dotests_1406();
dotests_1407();
dotests_1408();
dotests_1409();
dotests_1410();
dotests_1411();
dotests_1412();
dotests_1413();
dotests_1414();
dotests_1415();
dotests_1416();
dotests_1417();
dotests_1418();
dotests_1419();
dotests_1420();
dotests_1421();
dotests_1422();
dotests_1423();
dotests_1424();
dotests_1425();
dotests_1426();
dotests_1427();
dotests_1428();
dotests_1429();
dotests_1430();
dotests_1431();
dotests_1432();
dotests_1433();
dotests_1434();
dotests_1435();
dotests_1436();
dotests_1437();
dotests_1438();
dotests_1439();
dotests_1440();
dotests_1441();
dotests_1442();
dotests_1443();
dotests_1444();
dotests_1445();
dotests_1446();
dotests_1447();
dotests_1448();
dotests_1449();
dotests_1450();
dotests_1451();
dotests_1452();
dotests_1453();
dotests_1454();
dotests_1455();
dotests_1456();
dotests_1457();
dotests_1458();
dotests_1459();
dotests_1460();
dotests_1461();
dotests_1462();
dotests_1463();
dotests_1464();
dotests_1465();
dotests_1466();
dotests_1467();
dotests_1468();
dotests_1469();
dotests_1470();
dotests_1471();
dotests_1472();
dotests_1473();
dotests_1474();
dotests_1475();
dotests_1476();
dotests_1477();
dotests_1478();
dotests_1479();
dotests_1480();
dotests_1481();
dotests_1482();
dotests_1483();
dotests_1484();
dotests_1485();
dotests_1486();
dotests_1487();
dotests_1488();
dotests_1489();
dotests_1490();
dotests_1491();
dotests_1492();
dotests_1493();
dotests_1494();
dotests_1495();
dotests_1496();
dotests_1497();
dotests_1498();
dotests_1499();
dotests_1500();
dotests_1501();
dotests_1502();
dotests_1503();
dotests_1504();
dotests_1505();
dotests_1506();
dotests_1507();
dotests_1508();
dotests_1509();
dotests_1510();
dotests_1511();
dotests_1512();
dotests_1513();
dotests_1514();
dotests_1515();
dotests_1516();
dotests_1517();
dotests_1518();
dotests_1519();
dotests_1520();
dotests_1521();
dotests_1522();
dotests_1523();
dotests_1524();
dotests_1525();
dotests_1526();
dotests_1527();
dotests_1528();
dotests_1529();
dotests_1530();
dotests_1531();
dotests_1532();
dotests_1533();
dotests_1534();
dotests_1535();
dotests_1536();
dotests_1537();
dotests_1538();
dotests_1539();
dotests_1540();
dotests_1541();
dotests_1542();
dotests_1543();
dotests_1544();
dotests_1545();
dotests_1546();
dotests_1547();
dotests_1548();
dotests_1549();
dotests_1550();
dotests_1551();
dotests_1552();
dotests_1553();
dotests_1554();
dotests_1555();
dotests_1556();
dotests_1557();
dotests_1558();
dotests_1559();
dotests_1560();
dotests_1561();
dotests_1562();
dotests_1563();
dotests_1564();
dotests_1565();
dotests_1566();
dotests_1567();
dotests_1568();
dotests_1569();
dotests_1570();
dotests_1571();
dotests_1572();
dotests_1573();
dotests_1574();
dotests_1575();
dotests_1576();
dotests_1577();
dotests_1578();
dotests_1579();
dotests_1580();
dotests_1581();
dotests_1582();
dotests_1583();
dotests_1584();
dotests_1585();
dotests_1586();
dotests_1587();
dotests_1588();
dotests_1589();
dotests_1590();
dotests_1591();
dotests_1592();
dotests_1593();
dotests_1594();
dotests_1595();
dotests_1596();
dotests_1597();
dotests_1598();
dotests_1599();
dotests_1600();
dotests_1601();
dotests_1602();
dotests_1603();
dotests_1604();
dotests_1605();
dotests_1606();
dotests_1607();
dotests_1608();
dotests_1609();
dotests_1610();
dotests_1611();
dotests_1612();
dotests_1613();
dotests_1614();
dotests_1615();
dotests_1616();
dotests_1617();
dotests_1618();
dotests_1619();
dotests_1620();
dotests_1621();
dotests_1622();
dotests_1623();
dotests_1624();
dotests_1625();
dotests_1626();
dotests_1627();
dotests_1628();
dotests_1629();
dotests_1630();
dotests_1631();
dotests_1632();
dotests_1633();
dotests_1634();
dotests_1635();
dotests_1636();
dotests_1637();
dotests_1638();
dotests_1639();
dotests_1640();
dotests_1641();
dotests_1642();
dotests_1643();
dotests_1644();
dotests_1645();
dotests_1646();
dotests_1647();
dotests_1648();
dotests_1649();
dotests_1650();
dotests_1651();
dotests_1652();
dotests_1653();
dotests_1654();
dotests_1655();
dotests_1656();
dotests_1657();
dotests_1658();
dotests_1659();
dotests_1660();
dotests_1661();
dotests_1662();
dotests_1663();
dotests_1664();
dotests_1665();
dotests_1666();
dotests_1667();
dotests_1668();
dotests_1669();
dotests_1670();
dotests_1671();
dotests_1672();
dotests_1673();
dotests_1674();
dotests_1675();
dotests_1676();
dotests_1677();
dotests_1678();
dotests_1679();
dotests_1680();
dotests_1681();
dotests_1682();
dotests_1683();
dotests_1684();
dotests_1685();
dotests_1686();
dotests_1687();
dotests_1688();
dotests_1689();
dotests_1690();
dotests_1691();
dotests_1692();
dotests_1693();
dotests_1694();
dotests_1695();
dotests_1696();
dotests_1697();
dotests_1698();
dotests_1699();
dotests_1700();
dotests_1701();
dotests_1702();
dotests_1703();
dotests_1704();
dotests_1705();
dotests_1706();
dotests_1707();
dotests_1708();
dotests_1709();
dotests_1710();
dotests_1711();
dotests_1712();
dotests_1713();
dotests_1714();
dotests_1715();
dotests_1716();
dotests_1717();
dotests_1718();
dotests_1719();
dotests_1720();
dotests_1721();
dotests_1722();
dotests_1723();
dotests_1724();
dotests_1725();
dotests_1726();
dotests_1727();
dotests_1728();
dotests_1729();
dotests_1730();
dotests_1731();
dotests_1732();
dotests_1733();
dotests_1734();
dotests_1735();
dotests_1736();
dotests_1737();
dotests_1738();
dotests_1739();
dotests_1740();
dotests_1741();
dotests_1742();
dotests_1743();
dotests_1744();
dotests_1745();
dotests_1746();
dotests_1747();
dotests_1748();
dotests_1749();
dotests_1750();
dotests_1751();
dotests_1752();
dotests_1753();
dotests_1754();
dotests_1755();
dotests_1756();
dotests_1757();
dotests_1758();
dotests_1759();
dotests_1760();
dotests_1761();
dotests_1762();
dotests_1763();
dotests_1764();
dotests_1765();
dotests_1766();
dotests_1767();
dotests_1768();
dotests_1769();
dotests_1770();
dotests_1771();
dotests_1772();
dotests_1773();
dotests_1774();
dotests_1775();
dotests_1776();
dotests_1777();
dotests_1778();
dotests_1779();
dotests_1780();
dotests_1781();
dotests_1782();
dotests_1783();
dotests_1784();
dotests_1785();
dotests_1786();
dotests_1787();
dotests_1788();
dotests_1789();
dotests_1790();
dotests_1791();
dotests_1792();
dotests_1793();
dotests_1794();
dotests_1795();
dotests_1796();
dotests_1797();
dotests_1798();
dotests_1799();
dotests_1800();
dotests_1801();
dotests_1802();
dotests_1803();
dotests_1804();
dotests_1805();
dotests_1806();
dotests_1807();
dotests_1808();
dotests_1809();
dotests_1810();
dotests_1811();
dotests_1812();
dotests_1813();
dotests_1814();
dotests_1815();
dotests_1816();
dotests_1817();
dotests_1818();
dotests_1819();
dotests_1820();
dotests_1821();
dotests_1822();
dotests_1823();
dotests_1824();
dotests_1825();
dotests_1826();
dotests_1827();
dotests_1828();
dotests_1829();
dotests_1830();
dotests_1831();
dotests_1832();
dotests_1833();
dotests_1834();
dotests_1835();
dotests_1836();
dotests_1837();
dotests_1838();
dotests_1839();
dotests_1840();
dotests_1841();
dotests_1842();
dotests_1843();
dotests_1844();
dotests_1845();
dotests_1846();
dotests_1847();
dotests_1848();
dotests_1849();
dotests_1850();
dotests_1851();
dotests_1852();
dotests_1853();
dotests_1854();
dotests_1855();
dotests_1856();
dotests_1857();
dotests_1858();
dotests_1859();
dotests_1860();
dotests_1861();
dotests_1862();
dotests_1863();
dotests_1864();
dotests_1865();
dotests_1866();
dotests_1867();
dotests_1868();
dotests_1869();
dotests_1870();
dotests_1871();
dotests_1872();
dotests_1873();
dotests_1874();
dotests_1875();
dotests_1876();
dotests_1877();
dotests_1878();
dotests_1879();
dotests_1880();
dotests_1881();
dotests_1882();
dotests_1883();
dotests_1884();
dotests_1885();
dotests_1886();
dotests_1887();
dotests_1888();
dotests_1889();
dotests_1890();
dotests_1891();
dotests_1892();
dotests_1893();
dotests_1894();
dotests_1895();
dotests_1896();
dotests_1897();
dotests_1898();
dotests_1899();
dotests_1900();
dotests_1901();
dotests_1902();
dotests_1903();
dotests_1904();
dotests_1905();
dotests_1906();
dotests_1907();
dotests_1908();
dotests_1909();
dotests_1910();
dotests_1911();
dotests_1912();
dotests_1913();
//dotests_1914();
dotests_1915();
dotests_1916();
dotests_1917();
dotests_1918();
dotests_1919();
dotests_1920();
dotests_1921();
dotests_1922();
dotests_1923();
dotests_1924();
dotests_1925();
dotests_1926();
dotests_1927();
dotests_1928();
dotests_1929();
dotests_1930();
dotests_1931();
dotests_1932();
dotests_1933();
dotests_1934();
dotests_1935();
dotests_1936();
dotests_1937();
dotests_1938();
dotests_1939();
dotests_1940();
dotests_1941();
dotests_1942();
dotests_1943();
dotests_1944();
dotests_1945();
dotests_1946();
dotests_1947();
dotests_1948();
dotests_1949();
dotests_1950();
dotests_1951();
dotests_1952();
dotests_1953();
dotests_1954();
dotests_1955();
dotests_1956();
dotests_1957();
dotests_1958();
dotests_1959();
dotests_1960();
dotests_1961();
dotests_1962();
dotests_1963();
dotests_1964();
dotests_1965();
dotests_1966();
dotests_1967();
dotests_1968();
dotests_1969();
dotests_1970();
dotests_1971();
dotests_1972();
dotests_1973();
dotests_1974();
dotests_1975();
dotests_1976();
dotests_1977();
dotests_1978();
dotests_1979();
dotests_1980();
dotests_1981();
dotests_1982();
dotests_1983();
dotests_1984();
dotests_1985();
dotests_1986();
dotests_1987();
dotests_1988();
dotests_1989();
dotests_1990();
dotests_1991();
dotests_1992();
dotests_1993();
dotests_1994();
dotests_1995();
dotests_1996();
dotests_1997();
dotests_1998();
dotests_1999();
dotests_2000();
dotests_2001();
dotests_2002();
dotests_2003();
dotests_2004();
dotests_2005();
dotests_2006();
dotests_2007();
dotests_2008();
dotests_2009();
dotests_2010();
dotests_2011();
dotests_2012();
dotests_2013();
dotests_2014();
dotests_2015();
dotests_2016();
dotests_2017();
dotests_2018();
dotests_2019();
dotests_2020();
dotests_2021();
dotests_2022();
dotests_2023();
dotests_2024();
dotests_2025();
dotests_2026();
dotests_2027();
dotests_2028();
dotests_2029();
dotests_2030();
dotests_2031();
dotests_2032();
dotests_2033();
dotests_2034();
dotests_2035();
dotests_2036();
dotests_2037();
dotests_2038();
dotests_2039();
dotests_2040();
dotests_2041();
dotests_2042();
dotests_2043();
dotests_2044();
dotests_2045();
dotests_2046();
dotests_2047();
dotests_2048();
dotests_2049();
dotests_2050();
dotests_2051();
dotests_2052();
dotests_2053();
dotests_2054();
dotests_2055();
dotests_2056();
dotests_2057();
dotests_2058();
dotests_2059();
dotests_2060();
dotests_2061();
dotests_2062();
dotests_2063();
dotests_2064();
dotests_2065();
dotests_2066();
dotests_2067();
dotests_2068();
dotests_2069();
dotests_2070();
dotests_2071();
dotests_2072();
dotests_2073();
dotests_2074();
dotests_2075();
dotests_2076();
dotests_2077();
dotests_2078();
dotests_2079();
dotests_2080();
dotests_2081();
dotests_2082();
dotests_2083();
dotests_2084();
dotests_2085();
dotests_2086();
dotests_2087();
dotests_2088();
dotests_2089();
dotests_2090();
dotests_2091();
dotests_2092();
dotests_2093();
dotests_2094();
dotests_2095();
dotests_2096();
dotests_2097();
dotests_2098();
dotests_2099();
dotests_2100();
dotests_2101();
dotests_2102();
dotests_2103();
dotests_2104();
dotests_2105();
dotests_2106();
dotests_2107();
dotests_2108();
dotests_2109();
dotests_2110();
dotests_2111();
dotests_2112();
dotests_2113();
dotests_2114();
dotests_2115();
dotests_2116();
dotests_2117();
dotests_2118();
dotests_2119();
dotests_2120();
dotests_2121();
dotests_2122();
dotests_2123();
dotests_2124();
dotests_2125();
dotests_2126();
dotests_2127();
dotests_2128();
dotests_2129();
dotests_2130();
dotests_2131();
dotests_2132();
dotests_2133();
dotests_2134();
dotests_2135();
dotests_2136();
dotests_2137();
dotests_2138();
dotests_2139();
dotests_2140();
dotests_2141();
dotests_2142();
dotests_2143();
dotests_2144();
dotests_2145();
dotests_2146();
dotests_2147();
dotests_2148();
dotests_2149();
dotests_2150();
dotests_2151();
dotests_2152();
dotests_2153();
dotests_2154();
dotests_2155();
dotests_2156();
dotests_2157();
dotests_2158();
dotests_2159();
dotests_2160();
dotests_2161();
dotests_2162();
dotests_2163();
dotests_2164();
dotests_2165();
dotests_2166();
dotests_2167();
dotests_2168();
dotests_2169();
dotests_2170();
dotests_2171();
dotests_2172();
dotests_2173();
dotests_2174();
dotests_2175();
dotests_2176();
dotests_2177();
dotests_2178();
dotests_2179();
dotests_2180();
dotests_2181();
dotests_2182();
dotests_2183();
dotests_2184();
dotests_2185();
dotests_2186();
dotests_2187();
dotests_2188();
dotests_2189();
dotests_2190();
dotests_2191();
dotests_2192();
dotests_2193();
dotests_2194();
dotests_2195();
dotests_2196();
dotests_2197();
dotests_2198();
dotests_2199();
dotests_2200();
dotests_2201();
dotests_2202();
dotests_2203();
dotests_2204();
dotests_2205();
dotests_2206();
dotests_2207();
dotests_2208();
dotests_2209();
dotests_2210();
dotests_2211();
dotests_2212();
dotests_2213();
dotests_2214();
dotests_2215();
dotests_2216();
dotests_2217();
dotests_2218();
dotests_2219();
dotests_2220();
dotests_2221();
dotests_2222();
dotests_2223();
dotests_2224();
dotests_2225();
dotests_2226();
dotests_2227();
dotests_2228();
dotests_2229();
dotests_2230();
dotests_2231();
dotests_2232();
dotests_2233();
dotests_2234();
dotests_2235();
dotests_2236();
dotests_2237();
dotests_2238();
dotests_2239();
dotests_2240();
dotests_2241();
dotests_2242();
dotests_2243();
dotests_2244();
dotests_2245();
dotests_2246();
dotests_2247();
dotests_2248();
dotests_2249();
dotests_2250();
dotests_2251();
dotests_2252();
dotests_2253();
dotests_2254();
dotests_2255();
dotests_2256();
dotests_2257();
dotests_2258();
dotests_2259();
dotests_2260();
dotests_2261();
dotests_2262();
dotests_2263();
dotests_2264();
dotests_2265();
dotests_2266();
dotests_2267();
dotests_2268();
dotests_2269();
dotests_2270();
dotests_2271();
dotests_2272();
dotests_2273();
dotests_2274();
dotests_2275();
dotests_2276();
dotests_2277();
dotests_2278();
dotests_2279();
dotests_2280();
dotests_2281();
dotests_2282();
dotests_2283();
dotests_2284();
dotests_2285();
dotests_2286();
dotests_2287();
dotests_2288();
dotests_2289();
dotests_2290();
dotests_2291();
dotests_2292();
dotests_2293();
dotests_2294();
dotests_2295();
dotests_2296();
dotests_2297();
dotests_2298();
dotests_2299();
dotests_2300();
dotests_2301();
dotests_2302();
dotests_2303();
dotests_2304();
dotests_2305();
dotests_2306();
dotests_2307();
dotests_2308();
dotests_2309();
dotests_2310();
dotests_2311();
dotests_2312();
dotests_2313();
dotests_2314();
dotests_2315();
dotests_2316();
dotests_2317();
dotests_2318();
dotests_2319();
dotests_2320();
dotests_2321();
dotests_2322();
dotests_2323();
dotests_2324();
dotests_2325();
dotests_2326();
dotests_2327();
dotests_2328();
dotests_2329();
dotests_2330();
dotests_2331();
dotests_2332();
dotests_2333();
dotests_2334();
dotests_2335();
dotests_2336();
dotests_2337();
dotests_2338();
dotests_2339();
dotests_2340();
dotests_2341();
dotests_2342();
dotests_2343();
dotests_2344();
dotests_2345();
dotests_2346();
dotests_2347();
dotests_2348();
dotests_2349();
dotests_2350();
dotests_2351();
dotests_2352();
dotests_2353();
dotests_2354();
dotests_2355();
dotests_2356();
dotests_2357();
dotests_2358();
dotests_2359();
dotests_2360();
dotests_2361();
dotests_2362();
dotests_2363();
dotests_2364();
dotests_2365();
dotests_2366();
dotests_2367();
dotests_2368();
dotests_2369();
dotests_2370();
dotests_2371();
dotests_2372();
dotests_2373();
dotests_2374();
dotests_2375();
dotests_2376();
dotests_2377();
dotests_2378();
dotests_2379();
dotests_2380();
dotests_2381();
dotests_2382();
dotests_2383();
dotests_2384();
dotests_2385();
dotests_2386();
dotests_2387();
dotests_2388();
dotests_2389();
dotests_2390();
dotests_2391();
dotests_2392();
dotests_2393();
dotests_2394();
dotests_2395();
dotests_2396();
dotests_2397();
dotests_2398();
dotests_2399();
dotests_2400();
dotests_2401();
dotests_2402();
dotests_2403();
dotests_2404();
dotests_2405();
dotests_2406();
dotests_2407();
dotests_2408();
dotests_2409();
dotests_2410();
dotests_2411();
dotests_2412();
dotests_2413();
dotests_2414();
dotests_2415();
dotests_2416();
dotests_2417();
dotests_2418();
dotests_2419();
dotests_2420();
dotests_2421();
dotests_2422();
dotests_2423();
dotests_2424();
dotests_2425();
dotests_2426();
dotests_2427();
dotests_2428();
dotests_2429();
dotests_2430();
dotests_2431();
dotests_2432();
dotests_2433();
dotests_2434();
dotests_2435();
dotests_2436();
dotests_2437();
dotests_2438();
dotests_2439();
dotests_2440();
dotests_2441();
dotests_2442();
dotests_2443();
dotests_2444();
dotests_2445();
dotests_2446();
dotests_2447();
dotests_2448();
dotests_2449();
dotests_2450();
dotests_2451();
dotests_2452();
dotests_2453();
dotests_2454();
dotests_2455();
dotests_2456();
dotests_2457();
dotests_2458();
dotests_2459();
dotests_2460();
dotests_2461();
dotests_2462();
dotests_2463();
dotests_2464();
dotests_2465();
dotests_2466();
dotests_2467();
dotests_2468();
dotests_2469();
dotests_2470();
dotests_2471();
dotests_2472();
dotests_2473();
dotests_2474();
dotests_2475();
dotests_2476();
dotests_2477();
dotests_2478();
dotests_2479();
dotests_2480();
dotests_2481();
dotests_2482();
dotests_2483();
dotests_2484();
dotests_2485();
dotests_2486();
dotests_2487();
dotests_2488();
dotests_2489();
dotests_2490();
dotests_2491();
dotests_2492();
dotests_2493();
dotests_2494();
dotests_2495();
dotests_2496();
dotests_2497();
dotests_2498();
dotests_2499();
dotests_2500();
dotests_2501();
dotests_2502();
dotests_2503();
dotests_2504();
dotests_2505();
dotests_2506();
dotests_2507();
dotests_2508();
dotests_2509();
dotests_2510();
dotests_2511();
dotests_2512();
dotests_2513();
dotests_2514();
dotests_2515();
dotests_2516();
dotests_2517();
dotests_2518();
dotests_2519();
dotests_2520();
dotests_2521();
dotests_2522();
dotests_2523();
dotests_2524();
dotests_2525();
dotests_2526();
dotests_2527();
dotests_2528();
dotests_2529();
dotests_2530();
dotests_2531();
dotests_2532();
dotests_2533();
dotests_2534();
dotests_2535();
dotests_2536();
dotests_2537();
dotests_2538();
dotests_2539();
dotests_2540();
dotests_2541();
dotests_2542();
dotests_2543();
dotests_2544();
dotests_2545();
dotests_2546();
dotests_2547();
dotests_2548();
dotests_2549();
dotests_2550();
dotests_2551();
dotests_2552();
dotests_2553();
dotests_2554();
dotests_2555();
dotests_2556();
dotests_2557();
dotests_2558();
dotests_2559();
dotests_2560();
dotests_2561();
dotests_2562();
dotests_2563();
dotests_2564();
dotests_2565();
dotests_2566();
dotests_2567();
dotests_2568();
dotests_2569();
dotests_2570();
dotests_2571();
dotests_2572();
dotests_2573();
dotests_2574();
dotests_2575();
dotests_2576();
dotests_2577();
dotests_2578();
dotests_2579();
dotests_2580();
dotests_2581();
dotests_2582();
dotests_2583();
dotests_2584();
dotests_2585();
dotests_2586();
dotests_2587();
dotests_2588();
dotests_2589();
dotests_2590();
dotests_2591();
dotests_2592();
dotests_2593();
dotests_2594();
dotests_2595();
dotests_2596();
dotests_2597();
dotests_2598();
dotests_2599();
dotests_2600();
dotests_2601();
dotests_2602();
dotests_2603();
dotests_2604();
dotests_2605();
dotests_2606();
dotests_2607();
dotests_2608();
dotests_2609();
dotests_2610();
dotests_2611();
dotests_2612();
dotests_2613();
dotests_2614();
dotests_2615();
dotests_2616();
dotests_2617();
dotests_2618();
dotests_2619();
dotests_2620();
dotests_2621();
dotests_2622();
dotests_2623();
dotests_2624();
dotests_2625();
dotests_2626();
dotests_2627();
dotests_2628();
dotests_2629();
dotests_2630();
dotests_2631();
dotests_2632();
dotests_2633();
dotests_2634();
dotests_2635();
dotests_2636();
dotests_2637();
dotests_2638();
dotests_2639();
dotests_2640();
dotests_2641();
dotests_2642();
dotests_2643();
dotests_2644();
dotests_2645();
dotests_2646();
dotests_2647();
dotests_2648();
dotests_2649();
dotests_2650();
dotests_2651();
dotests_2652();
dotests_2653();
dotests_2654();
dotests_2655();
dotests_2656();
dotests_2657();
dotests_2658();
dotests_2659();
dotests_2660();
dotests_2661();
dotests_2662();
dotests_2663();
dotests_2664();
dotests_2665();
dotests_2666();
dotests_2667();
dotests_2668();
dotests_2669();
dotests_2670();
dotests_2671();
dotests_2672();
dotests_2673();
dotests_2674();
dotests_2675();
dotests_2676();
dotests_2677();
dotests_2678();
dotests_2679();
dotests_2680();
dotests_2681();
dotests_2682();
dotests_2683();
dotests_2684();
dotests_2685();
dotests_2686();
dotests_2687();
dotests_2688();
dotests_2689();
dotests_2690();
dotests_2691();
dotests_2692();
dotests_2693();
dotests_2694();
dotests_2695();
dotests_2696();
dotests_2697();
dotests_2698();
dotests_2699();
dotests_2700();
dotests_2701();
dotests_2702();
dotests_2703();
dotests_2704();
dotests_2705();
dotests_2706();
dotests_2707();
dotests_2708();
dotests_2709();
dotests_2710();
dotests_2711();
dotests_2712();
dotests_2713();
dotests_2714();
dotests_2715();
dotests_2716();
dotests_2717();
dotests_2718();
dotests_2719();
dotests_2720();
dotests_2721();
dotests_2722();
dotests_2723();
dotests_2724();
dotests_2725();
dotests_2726();
dotests_2727();
dotests_2728();
dotests_2729();
dotests_2730();
dotests_2731();
dotests_2732();
dotests_2733();
dotests_2734();
dotests_2735();
dotests_2736();
dotests_2737();
dotests_2738();
dotests_2739();
dotests_2740();
dotests_2741();
dotests_2742();
dotests_2743();
dotests_2744();
dotests_2745();
dotests_2746();
dotests_2747();
dotests_2748();
dotests_2749();
dotests_2750();
dotests_2751();
dotests_2752();
dotests_2753();
dotests_2754();
dotests_2755();
dotests_2756();
dotests_2757();
dotests_2758();
dotests_2759();
dotests_2760();
dotests_2761();
dotests_2762();
dotests_2763();
dotests_2764();
dotests_2765();
dotests_2766();
dotests_2767();
dotests_2768();
dotests_2769();
dotests_2770();
dotests_2771();
dotests_2772();
dotests_2773();
dotests_2774();
dotests_2775();
dotests_2776();
dotests_2777();
dotests_2778();
dotests_2779();
dotests_2780();
dotests_2781();
dotests_2782();
dotests_2783();
dotests_2784();
dotests_2785();
dotests_2786();
dotests_2787();
dotests_2788();
dotests_2789();
dotests_2790();
dotests_2791();
dotests_2792();
dotests_2793();
dotests_2794();
dotests_2795();
dotests_2796();
dotests_2797();
dotests_2798();
dotests_2799();
dotests_2800();
dotests_2801();
dotests_2802();
dotests_2803();
dotests_2804();
dotests_2805();
dotests_2806();
dotests_2807();
dotests_2808();
dotests_2809();
dotests_2810();
dotests_2811();
dotests_2812();
dotests_2813();
dotests_2814();
dotests_2815();
dotests_2816();
dotests_2817();
dotests_2818();
dotests_2819();
dotests_2820();
dotests_2821();
dotests_2822();
dotests_2823();
dotests_2824();
dotests_2825();
dotests_2826();
dotests_2827();
dotests_2828();
dotests_2829();
dotests_2830();
dotests_2831();
dotests_2832();
dotests_2833();
dotests_2834();
dotests_2835();
dotests_2836();
dotests_2837();
dotests_2838();
dotests_2839();
dotests_2840();
dotests_2841();
dotests_2842();
dotests_2843();
dotests_2844();
dotests_2845();
dotests_2846();
dotests_2847();
dotests_2848();
dotests_2849();
dotests_2850();
dotests_2851();
dotests_2852();
dotests_2853();
dotests_2854();
dotests_2855();
dotests_2856();
dotests_2857();
dotests_2858();
dotests_2859();
dotests_2860();
dotests_2861();
dotests_2862();
dotests_2863();
dotests_2864();
dotests_2865();
dotests_2866();
dotests_2867();
dotests_2868();
dotests_2869();
dotests_2870();
dotests_2871();
dotests_2872();
dotests_2873();
dotests_2874();
dotests_2875();
dotests_2876();
dotests_2877();
dotests_2878();
dotests_2879();
dotests_2880();
dotests_2881();
dotests_2882();
dotests_2883();
dotests_2884();
dotests_2885();
dotests_2886();
dotests_2887();
dotests_2888();
dotests_2889();
dotests_2890();
dotests_2891();
dotests_2892();
dotests_2893();
dotests_2894();
dotests_2895();
dotests_2896();
dotests_2897();
dotests_2898();
dotests_2899();
dotests_2900();
dotests_2901();
dotests_2902();
dotests_2903();
dotests_2904();
dotests_2905();
dotests_2906();
dotests_2907();
dotests_2908();
dotests_2909();
dotests_2910();
dotests_2911();
dotests_2912();
dotests_2913();
dotests_2914();
dotests_2915();
dotests_2916();
dotests_2917();
dotests_2918();
dotests_2919();
dotests_2920();
dotests_2921();
dotests_2922();
dotests_2923();
dotests_2924();
dotests_2925();
dotests_2926();
dotests_2927();
dotests_2928();
dotests_2929();
dotests_2930();
dotests_2931();
dotests_2932();
dotests_2933();
dotests_2934();
dotests_2935();
dotests_2936();
dotests_2937();
dotests_2938();
dotests_2939();
dotests_2940();
dotests_2941();
dotests_2942();
dotests_2943();
dotests_2944();
dotests_2945();
dotests_2946();
dotests_2947();
dotests_2948();
dotests_2949();
dotests_2950();
dotests_2951();
dotests_2952();
dotests_2953();
dotests_2954();
dotests_2955();
dotests_2956();
dotests_2957();
dotests_2958();
dotests_2959();
dotests_2960();
dotests_2961();
dotests_2962();
dotests_2963();
dotests_2964();
dotests_2965();
dotests_2966();
dotests_2967();
dotests_2968();
dotests_2969();
dotests_2970();
dotests_2971();
dotests_2972();
dotests_2973();
dotests_2974();
dotests_2975();
dotests_2976();
dotests_2977();
dotests_2978();
dotests_2979();
dotests_2980();
dotests_2981();
dotests_2982();
dotests_2983();
dotests_2984();
dotests_2985();
dotests_2986();
dotests_2987();
dotests_2988();
dotests_2989();
dotests_2990();
dotests_2991();
dotests_2992();
dotests_2993();
dotests_2994();
dotests_2995();
dotests_2996();
dotests_2997();
dotests_2998();
dotests_2999();
dotests_3000();
dotests_3001();
dotests_3002();
dotests_3003();
dotests_3004();
dotests_3005();
dotests_3006();
dotests_3007();
dotests_3008();
dotests_3009();
dotests_3010();
dotests_3011();
dotests_3012();
dotests_3013();
dotests_3014();
dotests_3015();
dotests_3016();
dotests_3017();
dotests_3018();
dotests_3019();
dotests_3020();
dotests_3021();
dotests_3022();
dotests_3023();
dotests_3024();
dotests_3025();
dotests_3026();
dotests_3027();
dotests_3028();
dotests_3029();
dotests_3030();
dotests_3031();
dotests_3032();
dotests_3033();
dotests_3034();
dotests_3035();
dotests_3036();
dotests_3037();
dotests_3038();
dotests_3039();
dotests_3040();
dotests_3041();
dotests_3042();
dotests_3043();
dotests_3044();
dotests_3045();
dotests_3046();
dotests_3047();
dotests_3048();
dotests_3049();
dotests_3050();
dotests_3051();
dotests_3052();
dotests_3053();
dotests_3054();
dotests_3055();
dotests_3056();
dotests_3057();
dotests_3058();
dotests_3059();
dotests_3060();
dotests_3061();
dotests_3062();
dotests_3063();
dotests_3064();
dotests_3065();
dotests_3066();
dotests_3067();
dotests_3068();
dotests_3069();
dotests_3070();
dotests_3071();
dotests_3072();
dotests_3073();
dotests_3074();
dotests_3075();
dotests_3076();
dotests_3077();
dotests_3078();
dotests_3079();
dotests_3080();
dotests_3081();
dotests_3082();
dotests_3083();
dotests_3084();
dotests_3085();
dotests_3086();
dotests_3087();
dotests_3088();
dotests_3089();
dotests_3090();
dotests_3091();
dotests_3092();
dotests_3093();
dotests_3094();
dotests_3095();
dotests_3096();
dotests_3097();
dotests_3098();
dotests_3099();
dotests_3100();
dotests_3101();
dotests_3102();
dotests_3103();
dotests_3104();
dotests_3105();
dotests_3106();
dotests_3107();
dotests_3108();
dotests_3109();
dotests_3110();
dotests_3111();
dotests_3112();
dotests_3113();
dotests_3114();
dotests_3115();
dotests_3116();
dotests_3117();
dotests_3118();
dotests_3119();
dotests_3120();
dotests_3121();
dotests_3122();
dotests_3123();
dotests_3124();
dotests_3125();
dotests_3126();
dotests_3127();
dotests_3128();
dotests_3129();
dotests_3130();
dotests_3131();
dotests_3132();
dotests_3133();
dotests_3134();
dotests_3135();
dotests_3136();
dotests_3137();
dotests_3138();
dotests_3139();
dotests_3140();
dotests_3141();
dotests_3142();
dotests_3143();
dotests_3144();
dotests_3145();
dotests_3146();
dotests_3147();
dotests_3148();
dotests_3149();
dotests_3150();
dotests_3151();
dotests_3152();
dotests_3153();
dotests_3154();
dotests_3155();
dotests_3156();
dotests_3157();
dotests_3158();
dotests_3159();
dotests_3160();
dotests_3161();
dotests_3162();
dotests_3163();
dotests_3164();
dotests_3165();
dotests_3166();
dotests_3167();
dotests_3168();
dotests_3169();
dotests_3170();
dotests_3171();
dotests_3172();
dotests_3173();
dotests_3174();
dotests_3175();
dotests_3176();
dotests_3177();
dotests_3178();
dotests_3179();
dotests_3180();
dotests_3181();
dotests_3182();
dotests_3183();
dotests_3184();
dotests_3185();
dotests_3186();
dotests_3187();
dotests_3188();
dotests_3189();
dotests_3190();
dotests_3191();
dotests_3192();
dotests_3193();
dotests_3194();
dotests_3195();
dotests_3196();
dotests_3197();
dotests_3198();
dotests_3199();
dotests_3200();
dotests_3201();
dotests_3202();
dotests_3203();
dotests_3204();
dotests_3205();
dotests_3206();
dotests_3207();
dotests_3208();
dotests_3209();
dotests_3210();
dotests_3211();
dotests_3212();
dotests_3213();
dotests_3214();
dotests_3215();
dotests_3216();
dotests_3217();
dotests_3218();
dotests_3219();
dotests_3220();
dotests_3221();
dotests_3222();
dotests_3223();
dotests_3224();
dotests_3225();
dotests_3226();
dotests_3227();
dotests_3228();
dotests_3229();
dotests_3230();
dotests_3231();
dotests_3232();
dotests_3233();
dotests_3234();
dotests_3235();
dotests_3236();
dotests_3237();
dotests_3238();
dotests_3239();
dotests_3240();
dotests_3241();
dotests_3242();
dotests_3243();
dotests_3244();
dotests_3245();
dotests_3246();
dotests_3247();
dotests_3248();
dotests_3249();
dotests_3250();
dotests_3251();
dotests_3252();
dotests_3253();
dotests_3254();
dotests_3255();
dotests_3256();
dotests_3257();
dotests_3258();
dotests_3259();
dotests_3260();
dotests_3261();
dotests_3262();
dotests_3263();
dotests_3264();
dotests_3265();
dotests_3266();
dotests_3267();
dotests_3268();
dotests_3269();
dotests_3270();
dotests_3271();
dotests_3272();
dotests_3273();
dotests_3274();
dotests_3275();
dotests_3276();
dotests_3277();
dotests_3278();
dotests_3279();
dotests_3280();
dotests_3281();
dotests_3282();
dotests_3283();
dotests_3284();
dotests_3285();
dotests_3286();
dotests_3287();
dotests_3288();
dotests_3289();
dotests_3290();
dotests_3291();
dotests_3292();
dotests_3293();
dotests_3294();
dotests_3295();
dotests_3296();
dotests_3297();
dotests_3298();
dotests_3299();
dotests_3300();
dotests_3301();
dotests_3302();
dotests_3303();
dotests_3304();
dotests_3305();
dotests_3306();
dotests_3307();
dotests_3308();
dotests_3309();
dotests_3310();
dotests_3311();
dotests_3312();
dotests_3313();
dotests_3314();
dotests_3315();
dotests_3316();
dotests_3317();
dotests_3318();
dotests_3319();
dotests_3320();
dotests_3321();
dotests_3322();
dotests_3323();
dotests_3324();
dotests_3325();
dotests_3326();
dotests_3327();
dotests_3328();
dotests_3329();
dotests_3330();
dotests_3331();
dotests_3332();
dotests_3333();
dotests_3334();
dotests_3335();
dotests_3336();
dotests_3337();
dotests_3338();
dotests_3339();
dotests_3340();
dotests_3341();
dotests_3342();
dotests_3343();
dotests_3344();
dotests_3345();
dotests_3346();
dotests_3347();
dotests_3348();
dotests_3349();
dotests_3350();
dotests_3351();
dotests_3352();
dotests_3353();
dotests_3354();
dotests_3355();
dotests_3356();
dotests_3357();
dotests_3358();
dotests_3359();
dotests_3360();
dotests_3361();
dotests_3362();
dotests_3363();
dotests_3364();
dotests_3365();
printf("Test result: %s\n", failed ? "FAILED" : "PASSED");
return failed;
}